text:
InfraKit Instance Plugin for VMWare Fusion
==========================================

## Status

POC only.

This is a proof of concept of an instance plugin for [InfraKit](https://github.com/docker/infrakit).
Currently you can use this plugin with a plain vanilla flavor plugin and the default group plugin to
manage a group of VMs via VMWare Fusion (which runs on the Mac and Windows).  You can scale up/down and suspend
VM instances and see new instances get created to ensure group size.

This is built on [VIX](http://blogs.vmware.com/vix/) using an open source Golang C-binding of the API.  So building
and running requires some special care (for cgo and requires dynamic linking).

VM instances are created by 'cloning' an existing `vmx` file.  VMX files are expected to be stored on disk as
children in the top level directory specified by the `--vm-lib` flag on start up of the plugin.

States of indivdual VM instances are stored as subdirectories of a top level directory specified by the `--vm-dir` flag
on startup of the plugin.

You can create your own VM using whatever image you want.  Then copy the whole directory (using the `${name}.vmwarevm`)
into the vm lib folder (see `./vmx`).  Then in your JSON, just reference this basename of the vmx.
See example below.

## Limitations / Next Steps

Currently, it's not possible to perform cloudinit-like execution of init scripts unless they are baked into the image.
It would be nice to be able to inject the scripts via the Flavor plugin, but the VIX API requires the [VM Tools](https://blogs.vmware.com/vsphere/2015/09/vmware-tools-10-0-0-released.html)
drivers or [Open VM Tools](https://github.com/vmware/open-vm-tools) (for example, on Alpine
[Open VM Tools](https://pkgs.alpinelinux.org/package/edge/main/x86/open-vm-tools))
package to be installed in the image.

References

  + https://github.com/rancher/os/issues/219
  + https://pkgs.alpinelinux.org/package/edge/main/x86/open-vm-tools
  + https://github.com/higebu/packer-alpine/blob/master/scripts/provisioning.sh

## Building

```shell
make plugins
```

This will put a binary in `build`

Note that there are some ISOs missing and you need to make sure they are in the `iso/` directory.

```shell
make vmx-alpine
```
will download an iso image from alpine repo and place that in the `iso/` directory.
A `.vmx` file will be generated off the template using the absolute path of the iso file.

If you have access to mobylinux, change the `Makefile` to clone from the correct repo, and run
`make qemu-iso`.  Place the built iso in the `iso/` directory and do

```shell
make vmx-moby
```

This will generate a vmx file using the correct absolute path that points to the mobylinux iso.

## Running

*For Go 1.6 or above -- You need to set an environment variable to disable cgo's dynamic checking*.

```shell
export GODEBUG=cgocheck=0
```

```shell
# On OSX
export DYLD_LIBRARY_PATH=$(pwd)/vendor/libvix
```

```shell
# On linux
export LD_LIBRARY_PATH=$(pwd)/vendor/libvix
```

From the current directory (repo root), run

```shell
./build/infrakit-instance-vmware-fusion --log=5 --vm-dir=./vms --vm-lib=./vmx
```

The flag `--vm-dir` is where the vm instances will be placed (their state, vmdk, etc.), and
`--vm-lib` is the top level directory where templated vmx directories are.

When the plugin provisions a new instance, it uses the `VMX` field in the config and the
`--vm-lib` flag to determine where the VMX file can be found.  It uses this rule...
Given the `--vm-lib` flag as `${vmlib}` and the `VMX` field in the following JSON for managing
a group (using the default group plugin and `vanilla` flavor):

```json
{
    "ID": "vmware_fusion_demo",
    "Properties": {
        "Instance" : {
            "Plugin": "vmware-fusion",
            "Properties": {
                "Tags" : {
                    "env" : "dev",
                    "instance-plugin" : "fusion"
                },
                "VMX" : "alpine-3.4.4",
                "MemorySizeMBs" : 512,
                "NumCPUs" : 2,
                "LaunchGUI" : true
            }
        },
        "Flavor" : {
            "Plugin": "flavor-vanilla",
            "Properties": {
                "Size" : 5
            }
        }
    }
}
```

The VMX file path will be computed as `${vmlib}/${VMX}.vmwarevm/${VMX}.vmx`.

Once the VMX file is located, it is cloned to provision a new instance.  The state of the new VM will
be placed in the `--vm-dir` subdirectory.

This provides a simple mechanism for supporting different image types.

repository: chungers/infrakit-vmware-fusion

gha_language: Go

repo_name: chungers/infrakit-vmware-fusion


text:
# vue-i18n for Server-Side Rendering

> This examples is based on vue-hackernews-2.0

## Build Setup

**Requires Node.js 7+**

``` bash
# install dependencies
npm install # or yarn

# serve in dev mode, with hot reload at localhost:8080
npm run dev

# build for production
npm run build

# serve in production mode
npm start
```

## License

MIT

license: MIT

extension: md

gha_language: JavaScript

gha_license_id: MIT

license_type: permissive


text:
# Visit-counter for a Director

Scenario: Show patient visits during working days and holidays.
  Given:foot-fall sensor data.
  When:patient visits on both working days and holidays.
  Then:count the number of patients visited.
Scenario: Compute parking slots to reserve for visiting specialists.
  Given:hospital staff attendance system data.
  When:specialists visit.
  Then:increase the count and compute parking slots.

branch_name: refs/heads/master


text:
# ConditionWatcher

Article explaining

Simple class created in order to make Android automation testing easier, faster, cleaner and more intuitive. It synchronizes operations that might occur on any thread - with test thread. ConditionWatcher can be used as a replacement to Espresso's IdlingResources or it can work in parallel with them.

When we started our adventure with Android Espresso, we came across with various problems connected to IdlingResources. Before we were able to understand how Espresso works on lower layer and explain behaviour of IdlingResources, we created our own tool beforehand and based tests on it. As we can see now principle of operation is very similar, yet we would like present to you perks of ConditionWatcher as they might become useful to you.

Related article: [Wait for it… IdlingResource and ConditionWatcher](https://medium.com/azimolabs/wait-for-it-idlingresource-and-conditionwatcher-602055f32356#.ja9nytoe9)

## Quick Start
If you want to check how ConditionWatcher works by yourself, you can run tests included in sample project.

1. Pull ConditionWatcher project from GitHub
2. Connect Android device or start AVD.
3. Run [test examples](https://github.com/AzimoLabs/ConditionWatcher/tree/master/sample/src/androidTest/java/com/azimolabs/f1sherkk/conditionwatcherexample) included in sample project by:

	a) Android Studio - locate test files: ConditionWatcherExampleTests.java and IdlingResourceExampleTests.java. Select test class that you want to launch. Choose `Run` task from menu that appears after right-clicking it.

	![TestPackage](https://raw.githubusercontent.com/AzimoLabs/ConditionWatcher/master/art/testPackage.png)

	b) Command line - open terminal and change directory to the root of the ConditionWatcher project. Execute `./gradlew sample:connectedCheck` to run whole test suite.

## Usage

ConditionWatcher doesn't need any setup. After classes are added to your project you are ready to go.

##### ConditionWatcher.java - performs wait
Singleton which is automatically created after call to any of it's methods. It is meant to be destroyed along with test process. To make test code wait, you need to call `waitForCondition(Instruction instruction)` method. ConditionWatcher will check if the expected state is achieved with `250ms interval` and throw `timeout exception after 60 seconds`. Those values `can be easly changed` and each wait case can be handled separately.

##### Instruction.java - informs what to wait for
It provides ConditionWatcher with information what should be scanned and when conditions are met. ConditionWatcher will keep calling Instrucion's `checkCondition()` method with interval until it returns true. Furthermore Instruction contains `getDescription()` method where you can place additional logs (for example dump of elements connected to your current wait).

ConditionWatcher in test code looks like that:

```java
@Test
public void shouldDisplayServerDetails_conditionWatcher() throws Exception {
    List<Server> servers = DataProvider.generateServerList();
    Server thirdServer = servers.get(2);

    // SplashActivity
    ConditionWatcher.waitForCondition(new BtnStartAnimationInstruction());
    onView(withId(R.id.btnStart)).perform(click());

    // ListActivity
    ConditionWatcher.waitForCondition(new ServerListLoadingInstruction());
    onData(anything()).inAdapterView(withId(R.id.lvList)).atPosition(2).perform(click());

    // DetailsActivity
    ConditionWatcher.waitForCondition(new LoadingDialogInstruction());
    onView(withText(thirdServer.getName())).check(matches(isDisplayed()));
    onView(withText(thirdServer.getAddress())).check(matches(isDisplayed()));
    onView(withText(thirdServer.getPort())).check(matches(isDisplayed()));
}

```

Example of one instruction which waits until loading dialog disappear from view hierarchy:

```java
public class LoadingDialogInstruction extends Instruction {
    @Override
    public String getDescription() {
        return "Loading dialog shouldn't be in view hierarchy";
    }

    @Override
    public boolean checkCondition() {
        Activity activity = ((TestApplication)
                InstrumentationRegistry.getTargetContext().getApplicationContext()).getCurrentActivity();
        if (activity == null) return false;

        DialogFragment f =
            (DialogFragment) activity.getFragmentManager().findFragmentByTag(LoadingDialog.TAG);
        return f == null;
    }
}
```

Full code can be found in provided sample project. It also contains the same test created with usage of IdlingResources with exactly the same logic to pinpoint the differences.

## Why ConditionWatcher?

##### - It is fast! - save time on synchronization
You are provided with `setWatchInterval()` method which allows you to change interval with which `ConditionWatcher` checks if all conditions are met and if test can continue. In comparison to `IdlingResource` if method `isIdleNow()` returns false, framework waits 5 seconds before it checks your condition again. It doesn't only limits your options but also forces test to wait without real need.

##### - It is clean! - reduce number of lines in your code
`ConditionWatcher`'s wait `Instruction` objects are reusable. Consequently you don't need to unregister them before next usage. `IdlingResource` is added to `List` stored in  `IdlingResourceRegistry` class. That List can't store two objects with the same name. Furthermore once `IdlingResource` is idled, it becomes unusable until you unregister it and register again.

##### - Less restrictions! - you are the master of your own test
`IdlingResource` after registered within `IdlingResourceRegistry` starts to wait for app's idle state only after Espresso method was called within test. So you have to use either `perform()` or `check()` to wait for idle. `ConditionWatcher` is not connected to Espresso framework. It uses simple `Thread.sleep()` method which makes your test thread to wait until condition is met. You can decide what to wait for, how and when.

##### - It is easy! - be creative, modify the way you like

`ConditionWatcher` consists of 51 lines of code. It is very easy to understand and you can adjust it to your needs. Each app is different after all.

##### - It is intuitive! - there is no black box part

You don't have to be worried of unexpected behaviours. `ConditionWatcher` will stop waiting for your condition instantly after method `checkCondition()` returns true.  If you haven't noticed it yet, `IdlingResource`'s method `isIdleNow()` is still being called a few times (with ~1ms interval) after it returns true.

## Download

### Library dependency

```gradle
dependencies {
  androidTestCompile 'com.azimolabs.conditionwatcher:conditionwatcher:0.1'
}
```

### Java code

If you don't want to add another dependency to your project, just copy [ConditionWatcher.java](https://github.com/AzimoLabs/ConditionWatcher/blob/master/conditionwatcher/src/main/java/com/azimolabs/conditionwatcher/ConditionWatcher.java) and [Instruction.java](https://github.com/AzimoLabs/ConditionWatcher/blob/master/conditionwatcher/src/main/java/com/azimolabs/conditionwatcher/Instruction.java) classes to your source directory.

## License

    Copyright (C) 2016 Azimo

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.


text:
This changelog highlights changes as we work to implement version 1.0.0.

# [1.0.0-pre.1]
* BREAKING CHANGES (see the [Migration Guide](https://github.com/Sub6Resources/flutter_html/wiki/1.0.0-Migration-Guide) for a full overview of breaking changes.):
  * The default parser has been completely rewritten and the RichText parser has been deprecated.
  * `useRichText` now defaults to `false` (the new parser uses RichText, though)
  * `customRender` now works for the default parser.
* Adds support for `<audio>`, `<video>`, `<iframe>`, `<svg>`, `<ruby>`, `<rt>`, `<rp>`, `<sub>`, and `<sup>`
* Adds support for over 20 CSS attributes.
* Fixes 22 issues (see the list at [#122](https://github.com/Sub6Resources/flutter_html/pull/122))
* The following parameters of `Html` have been deprecated and should no longer be used:
  * `useRichText`
  * `padding`
  * `backgroundColor`
  * `defaultTextStyle`
  * `renderNewlines`
  * `customEdgeInsets`
  * `customTextStyle`
  * `blockSpacing`
  * `customTextAlign`
  * `linkStyle`
  * `imageProperties`
  * `showImages`
* The default text style now matches the app's Material `TextTheme.body1` (Fixes [#18](https://github.com/Sub6Resources/flutter_html/issues/18)).
* Fixed quite a few issues with `img`
* Added a fancy new `style` attribute (this should be used in place of the deprecated styling parameters).


text:
# Civisubramaniania Vittal & Dorai GENUS

#### Status
ACCEPTED

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Trans. Br. mycol. Soc. 87(3): 482 (1986)

#### Original name
Civisubramaniania Vittal & Dorai

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
---
title: (emacs-berlin 'archive')
layout: default
---
{::options parse_block_html="true" /}

# `C-u 2017 M-x new-year RET`

The first meetup in 2017 will be on **January 25th**, back at our
traditional host Contentful, with two talks:

**Introduction to [Magit](https://magit.vc/) in Spacemacs** — by [Julia](https://twitter.com/anderspree)
<br>
How I became the only one at work that loves Rebasing.

[Jack Rusher](http://jackrusher.com/) uses Emacs for basically
everything for 30+ years and will **surprise us with something cool**!

There will also be time for lightning talks/demos and some food.

branch_name: refs/heads/main

gha_language: HTML


text:
# Memphis
Cross-platform GUI and Event System

Philosophy

0. The system will work with a minimum number of lines (3 lines: create, set up, use)
1. Protect users from memory leak (remove explicit new and delete)
2. It's easier to turn off a function than to turn it on
3. Warn user about possible problem
4. Make simple simple and difficult in simple pieces
5. Beautiful library code (no extra__ and gibberish)
6. Easy to build: everything in the header file
7. . instead ->
8. Anything Memphis can do automatically is done automatically

repository: Poarthur/memphis

repo_name: Poarthur/memphis


text:
# Response processor for Flask applications
This extension integrates an ``after_request`` function for a Flask application to execute a defined function whenever a specific status code from response occurs. The extension is useful in case it is necessary to perform an action whenever a status code occurs (e.g. sending a mail notification for internal server error codes).

The list of status codes that execute the defined function are specified by the ``REQUEST_RESPONSE_PROCESSOR_STATUS_CODES`` variable (via Flask configuration). If such list is empty, the ``after_request`` function will execute the defined function.

It is also possible to use the list of status codes that, if occurring, will not execute the desired function. This behavior is set with the flag ``REQUEST_RESPONSE_PROCESSOR_STATUS_CODES_EXCLUDE_ONLY`` (True | False).

## Requirements
* Python >= 3.8
* Flask

## Installation
Install the extension via *pip*:

```bash
pip install git<EMAIL_ADDRESS>```

## Example
The library can be accessed via ``FlaskRequestResponseProcessor`` class. The instance of this object needs to define the ``process_request_response`` behavior function via decorators. The function receives the following parameters: (1) Flask request; (2) Flask response; (3) start/end time for the request. In this function you can verify/process all the available information to pass it to the principal function you are trying to attempt whenever a status code is found (e.g. mail notification, response logging, etc.).

```python
import logging
from datetime import datetime
from flask import Flask, request as flask_request, abort
from flask_request_response_processor import FlaskRequestResponseProcessor, FlaskRequestFormatter, \
    FlaskResponseFormatter

app = Flask(__name__)

# List of status codes to filter
app.config['REQUEST_RESPONSE_PROCESSOR_STATUS_CODES'] = [500, 503]

# If True, all status codes will execute the process function,
# except those on the REQUEST_RESPONSE_PROCESSOR_STATUS_CODES list.
app.config['REQUEST_RESPONSE_PROCESSOR_STATUS_CODES_EXCLUDE_ONLY'] = False

"""
The FlaskRequestResponseProcessor object needs to define the 'process_request_response'
function via decorators.

Such function will be executed whenever the status code is on the configuration variable
'REQUEST_RESPONSE_PROCESSOR_STATUS_CODES' or if such list is empty.

The function receives the request and response objects, plus the start/end time for the
request. In this function you can verify/process all the available information to pass
it to the principal function you are trying to attempt whenever a status code is found
(e.g. mail notification, response logging, etc.).
"""
# Handler for response
response_handler = FlaskRequestResponseProcessor(app=app)

@response_handler.process_request_response
def process_request_response(request: flask_request,
                             request_start_time: datetime,
                             request_end_time: datetime,
                             response):
    """
    Extract available information from request and response
    :param request: flask.request object
    :param request_start_time: UTC start time for request
    :param request_end_time: UTC end time for request
    :param response: Response from processed resource
    :return:
    """
    """
    The extension includes 'FlaskRequestFormatter' and 'FlaskResponseFormatter'
    classes to retrieve some of the basic information from request and response.
    """
    request_formatter = FlaskRequestFormatter(request=request)
    response_formatter = FlaskResponseFormatter(response=response)

    payload = request_formatter.payload_json_compressed_str \
        if request_formatter.payload_is_json is True \
        else request_formatter.payload_raw

    response_data = response_formatter.response_json_compressed_str \
        if response_formatter.response_is_json \
        else response_formatter.response_raw

    request_time = str(request_end_time - request_start_time)

    # After processing data, you can send mail notifications, logging request, etc.
    logging.error({
        'status_code': response.status_code,
        'path': request.path,
        'payload': payload,
        'date': request_end_time.strftime('%d %B, %Y %H:%M:%S'),
        'time': request_time,
        'method': request.method,
        'response': response_data
    })

@app.route('/error', methods=['get'])
def error():
    abort(503)

@app.route('/ok', methods=['get'])
def ok():
    return 'Ok'

if __name__ == '__main__':
    app.run()
```

Delayed application configuration of ``FlaskRequestResponseProcessor`` is also supported using the ``init_app`` method:

```python
from flask import Flask
from flask_request_response_processor import FlaskRequestResponseProcessor

app = Flask(__name__)
response_handler = FlaskRequestResponseProcessor()
# ...
response_handler.init_app(app=app)
```

## Testing
To run the example code:
```bash
FLASK_APP=test.py FLASK_DEBUG=1 FLASK_ENV=development flask run
```

Execute the following tests using cURL:

### No execution of ``after_request``
```bash
curl -X GET http://<IP_ADDRESS>:5000/ok
```

### Execution of ``after_request``
```bash
curl -X GET http://<IP_ADDRESS>:5000/error
```


text:
+++
title = "Lab 1: VPCs"
chapter = true
weight = 20
+++

## Lab 1 VPCs

This lab shows some of the basic networking aspects of **Amazon Virtual Private Cloud (VPC)**.

You will deploy two VPCs and the Transit Gateway with a few clicks using **AWS Cloudformation**. You will then connect to an EC2 instance and verify connectivity to the internet via the NAT Gateway, as well as test connectivity to the other VPCs EC2 instance.

![TGW Diagram](/images/tgw-diagram.png)

The address of the **EC2 Instance** in **VPC64** is **<IP_ADDRESS>** and the address of the **EC2 Instance** in **VPC65** is **<IP_ADDRESS>**.

repository: geseib/awselbworkshop

repo_name: geseib/awselbworkshop


text:
# coffeescript-compiler
[Source code of released version](https://github.com/meteor/meteor/tree/master/packages/coffeescript-compiler) | [Source code of development version](https://github.com/meteor/meteor/tree/devel/packages/coffeescript-compiler)
***

This package supports the [`coffeescript`](../coffeescript/README.md) package,
and any other packages that wish to compile CoffeeScript code into JavaScript.
Like the [`babel-compiler`](../babel-compiler/README.md) package, the actual
compilation is separated out from the build plugin so that packages besides
the official `coffeescript` package can compile CoffeeScript code.

### Testing This Package

Testing the `coffeescript` package also tests this one:

```bash
./meteor test-packages packages/non-core/coffeescript
```

repository: meteor/meteor

branch_name: refs/heads/devel

gha_license_id: NOASSERTION

repo_name: meteor/meteor


text:
# Swase
Welcome to Swase!\
The better if statement; a switch case statement emulator!\
\
You can use it like this:
```py
from Swase.Switch import Switch

while True:
    cmd = input('> ')
    nest = Switch()
    nest.AddToSwitch(Input='Mercury', Outcome='print("You typed in Mercury!")')
    nest.LastSwitch(Input='Venus', Outcome='print("You typed in Venus!")', Else='print("Not available.")', Bind=cmd)
```
This code is the same as:
```py
while True:
    cmd = input('> ')
    if cmd == 'Mercury':
        print("You typed in Mercury!")
    elif cmd == 'Venus':
        print("You typed in Venus!")
    else:
        print("Not available.")
```
You don't have to define an `Else=''` statement if you don't need a default value.\
\
Every time you want to add a new statement, you have to use `AddToSwitch()`.\
## No matter how many statements you have, `LastSwitch()` always has to be at the end!
You can define the default statement with `LastSwitch(Else='...')`, and bind every statement you previously defined to your variable with `LastSwitch(Bind='...')`.


text:
---
id: transaction-type
title: "Transaction Type"
scopeid: essifLab
type: concept
typeid: transaction-type
stage: draft
hoverText: "Transaction Type (of some kind of Business Transaction and some Party): the Policy, Governed by that Party, and other necessary artifacts (e.g. a Transaction Form) that provide an Actor with all necessary means to conduct a Transaction of this type on behalf of that Party."
glossaryText: "the %%policy^policy%%, %%governed^governor%% by that %%party^party%%, and other necessary artifacts (e.g. a %%transaction form^transaction-form%%) that provide an %%actor^actor%% with all necessary means to conduct a %%transaction^transaction%% of this type on behalf of that %%party^party%%."
---

:::info Editor's note
TNO (or others) to provide the content of this file.
:::

repository: MarIliadi/ctwg-sandbox

repo_name: MarIliadi/ctwg-sandbox


text:
# Test Case: [BUG] - Text.textContent doesn't inherit from Node.textContent in JSDOM

## Test Case Code
https://drive.google.com/open?id=1IayEFjUReATiuJI8CD6hBQRPGR7iIrFZ

```js
// check file
app.component.spec.ts
```

## Topcoder handle

liqiang372

## Your document content (required)
### How to run test
#### Prerequisites

1. Node 8+
2. NPM or yarn
3. Git
4. Safari, Chrome, Firefox

#### Run Test on Karma

```bash
cd topcoder-jest-test
git checkout issue-29
npm install
npm run test
```
#### Run Test on Jest

```bash
npm run test:jest
```

### Browser have tested

Chrome, Safari, Firefox

### Test Result on Karma

| Browser | Result |
| ------ | ------ |
| Chrome 72.0.3626 (Mac OS X 10.14.2) | success |
| Safari 11.1.0 (Mac OS X 10.14.2)  | success |
| Firefox 65.0.0 (Mac OS X 10.14.2) | success |

### Test Result on Jest
#### What we get
```js
 FAIL  src/app/app.component.spec.ts
  AppComponent
    ✕ should create the app (85ms)

  ● AppComponent › should create the app

    AssertionError: expected 'hello,undefined' to equal 'hello, world'

      24 |
      25 |     parent.append(elem.textContent, text.textContent);
    > 26 |     expect(parent.textContent).to.equal('hello, world');
         |                                   ^
      27 |   });
      28 | });
      29 |

      at src/app/app.component.spec.ts:26:35

Test Suites: 1 failed, 1 total
Tests:       1 failed, 1 total
Snapshots:   0 total
Time:        2.332s
```
#### Expected
Expect `Text.textContent` can set the value correctly

## Description
It's JSDOM's inappropriate implementation of Text

issue: https://github.com/jsdom/jsdom/issues/2144

gha_language: TypeScript


text:
# Summary

* [Introduction](README.md)
* [App Starters](app-starters.md)
* [Development Strategy](development-strategy.md)
  * [Focus on one, check both](development-strategy/focus-on-one-check-both.md)
* [App Icons and Splash Screen](app-icons-and-splash-screen.md)
  * [Generate App Icon & Splash-screen Automatically](app-icons-and-splash-screen/automatic.md)
  * [Generate App Icon & Splash-screen Manually](app-icons-and-splash-screen/manual.md)
* [Renaming Your App](renaming-your-app.md)
  * [Rename App Automatically](renaming-your-app/rename-app-automatically.md)
  * [Rename App Manually Manual](renaming-your-app/rename-app-manually-manual.md)
* [Debugging your UI](debugging-your-ui.md)
  * React Devtools
* [Testing Your App](testing-your-app.md)
  * [Jest](testing-your-app/jest.md)
  * [Detox](testing-your-app/detox.md)
* [Keep Tabs On Native Logs](keep-tabs-on-native-logs.md)
* [Upgrade React Native with Caution!](upgrade-react-native-with-caution.md)
* [CI/CD Tools](cicd-tools.md)
* [Submission 🚀](submission-d83d-de80.md)
  * Fastlane
  * Common App Rejection Reasons

repository: harrisrobin/react-native-checklist

repo_name: harrisrobin/react-native-checklist


text:
route: home
title: Home

---

A simple static blog platform with tags. Made with Haskell and Scotty.

Hablog will read posts written in Markdown from the `_posts` folder.

License
=======

Hablog is licensed under MIT license. This means the Haskell source files in the src directory.
Highlight.js related content is not a part of Hablog and is not licensed by it.

Installation
============

```sh
git clone https://github.com/soupi/hablog
cd hablog
stack build
```

How to write a new post?
========================

1. All posts must go under the `/_posts/` directory
1. All pages must go under the `/_pages/` directory
3. The content of the post/page must correspond to a specific structure

## A Post's Structure

```markdown
title: <the title of the post>
route: <route to the post>
authors: <the author of the post, seperated, by, commas>
date: yyyy-mm-dd
tags: <tags for the post, separated, by, commas>

---

<The rest of the post in Markdown format>
```

## A Page's Structure

```markdown
title: <the title of the page>
route: <the route of the page>

---

<The rest of the post in Markdown format>
```

## Home page

The front page will either be `Home` or, if that isn't available, the blog page will be the front page.

repository: soupi/hablog

gha_language: Haskell

repo_name: soupi/hablog


text:
---
# Documentation: https://wowchemy.com/docs/managing-content/

title: Child sleep and socioeconomic context in the development of cognitive abilities
  in early childhood
subtitle: ''
summary: ''
authors:
- Caroline P. Hoyniak
- John E. Bates
- Angela D. Staples
- Kathleen M. Rudasill
- Dennis L. Molfese
- Victoria J. Molfese
tags: []
categories: []
date: '2018-09-01'
lastmod: 2021-02-04T20:44:30-05:00
featured: false
draft: false

# Featured image
# To use, add an image named `featured.jpg/png` to your page's folder.
# Focal points: Smart, Center, TopLeft, Top, TopRight, Left, Right, BottomLeft, Bottom, BottomRight.
image:
  caption: ''
  focal_point: ''
  preview_only: false

# Projects (optional).
#   Associate this post with one or more of your projects.
#   Simply enter your project's folder or file name without extension.
#   E.g. `projects = ["internal-project"]` references `content/project/deep-learning/index.md`.
#   Otherwise, set `projects = []`.
projects: []
publishDate: '2021-02-05T01:44:30.164540Z'
publication_types:
- '2'
abstract: Despite a robust literature examining the association between sleep problems
  and cognitive abilities in childhood, little is known about this association in
  toddlerhood, a period of rapid cognitive development. The present study examined
  the association between various sleep problems, using actigraphy, and performance
  on a standardized test of cognitive abilities, longitudinally across three ages
  (30, 36, and 42 months) in a large sample of toddlers (N = 493). Results revealed
  a between-subject effect in which the children who had more delayed sleep schedules
  on average also showed poorer cognitive abilities on average but did not support
  a within-subjects effect. Results also showed that delayed sleep explains part of
  the association between family socioeconomic context and child cognitive abilities.
publication: '*Child Development*'
url_pdf: http://doi.wiley.com/10.1111/cdev.13042 https://onlinelibrary.wiley.com/doi/abs/10.1111/cdev.13042
doi: 10.1111/cdev.13042
---

repository: astaples/starter-academic

repo_name: astaples/starter-academic


text:
# PanoPuppet

[![Join the chat at https://gitter.im/propyless/panopuppet](https://badges.gitter.im/propyless/panopuppet.svg)](https://gitter.im/propyless/panopuppet?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

### Important notice
Hello, I've recently started a new job and I don't have much time to invest in this project anymore. I recommended going for one of the projects with more contributors. The code is terrible here (I was learning python) so if you feel up for a challenge and want to keep the project alive, please get in touch.

---

PanoPuppet, Panorama Puppet or PP is a web frontend that interfaces with PuppetDB
and gives you a panorama view over your puppet environment(s).
PanoPuppet visualizes this data for you with lists and graphs.
You are able to browse through the latest changes in reports, nodes, resources,
classes and types. Many features were features requested by my colleagues.

Its coded using Python3 using the Django Framework for the web interface and
requests library to interface with puppetDB. It also uses Bootstrap for
the CSS and Jquery for some tablesorting.

The interface was written originally as an idea from work, we have tried to
use different types of web interfaces that show the status of the puppet
environment but found nothing that suited our needs from a security PoV.

Therefore its written and designed with an enterprise companies needs as a focus point.
Where there are many XFT's and where there may be a need for extra security to
limit the nodes a certain XFT/group should be allowed access too.

This was written for a multi-tenant site across several datacenters.

For the feature list click here:  [Features](#features)

To see how PanoPuppet looks click here: [Screenshots](https://github.com/propyless/panopuppet/wiki/Screenshots)

# Support
* PanoPuppet Releases >= 1.4.0 - Requires PuppetDB == 3.x/4.x (Uses the v4 api endpoint)
* PanoPuppet Releases >= 1.0.0 and <= 1.3.0 - Requires PuppetDB == 3.x (Uses the v4 api endpoint)
* PanoPuppet Releases < 1.0.0 - Requires PuppetDB == 2.x (Uses the experimental v4 api endpoint)

To download a specific release you can find them [Here](https://github.com/propyless/panopuppet/releases)

###Table of Contents

- [Features](#features)
- [Requirements](#requirements)
- [Supported OS](#supported-operating-systems)
- [Future plans](#future-plans)
- [Installation](#installation)
- [Upgrading](#upgrading)
- [QueryBuilder](#querybuilder)
- [LDAP Permissions](#ldap-permissions)
  - [Multiple Groups](#member-of-multiple-groups)
- [Configuration Options](#configuration-options)
- [Available branches](#available-branches)
- [Contact Me](#contact-me)
- [Development Server](#development-server)

## Features
* Fast and easy to use
* Uses PuppetDB API to retrieve information
* Filebucket and Fileserver support
* Diff support between old and new file
* Fully featured Dashboard for use with PuppetDB
* Analytics Page providing insight into your puppet environment
* LDAP Authentication
* LDAP Group Permissions - Restrict which servers a group can view
* Events Analyzer (Like Events Inspector from Puppet Enterprise)
* Search nodes by facts and subqueries (Query Builder)
* Export data to CSV with or without selected facts
* Catalogue Viewer
* Save catalogues
* Diff node catalogues using the current or previously saved catalogues

### Use Case
One large company, several hundred XFT's operating from multiples regions.
Security concious company where you may not always want the information available
in PuppetDB available to everyone. Difficult to lock down a ldap/AD group to a
subset of users in PuppetDB alone..

PanoPuppet gives you the ability to create PuppetDB Queries with a easy to use tool
and use those rules to lock down an active directory group to one or more PuppetDB Queries.

Users that have a rule will then only be able to see nodes that match the rule you created.

PanoPuppet enables you to control and delegate the information in PuppetDB to the users
who need it.

![PanoPuppet Design](screenshots/pp_workflow.png)

## Some random info and tips...
Since this django app can use LDAP/AD Authentication it can be a bit tricky
to get it working for all Actice Directory designs. The default config works
for the environment I tested it with. I have had other users reporting that
they had to change the ldap code to accept nested groups for example or use
another attr for the login name.
If you need help to get it working you are most welcome to create a support issue
in GitHub.

There is an example configuration for you to look at.
I'd suggest you make a copy and modify the lines you need too.

It is written with Python3, its not Python2 compatible and I
won't ever make it Python2 compatible.
It will be a bit of pain to get working on RHEL7 using SCL so you
will need to make a wrapper that enables SCL python3.

## Requirements
* PuppetDB requires at least PuppetDB 3.0 or higher (PDB 2.x is no longer supported from release v1.0.0)
* Puppetv3
* Python3
* Install requirements listed in requirements.txt
* Recommended to use virtualenv (+ virtualenvwrapper)

## Supported Operating Systems
* RHEL6,7
* CentOS6,7
* Ubuntu 14.04
* Debian 8 (jessie) - LDAP issues)

## Future plans
* Docker image to quickly install a PanoPuppet dashboard

## Installation
For install instructions they can be found in either INSTALL.md or at the PanoPuppet Wiki hosted at Github.
https://github.com/propyless/panopuppet/wiki/Installation-Guides

## Upgrading

### Classic install
Upgrading PanoPuppet should be no harder than doing a git pull origin/master in the /srv/repo/panopuppet directory.
But its recommended to run the `python manage.py collectstatic` command again in case new css/javascripts have been added so that they
are served to your clients. Also make sure to read the config.yaml.example file and see if any new variables have been
implemented!

### Setup.py install
Make sure you have the correct python in your path (virtual env users)
First uninstall the previous setup.py install of PanoPuppet with:

`pip uninstall panopuppet`

*If you have already installed the latest version of PanoPuppet you can remove the older version by specifying the version of PanoPuppet to remove, for example:*

`pip uninstall panopuppet==1.3`

Make sure you have checked out the latest release or master, run:

`python setup.py install`

Now you should be done, just run the **General upgrade commands** and you'll be good to go.

### General upgrade commands
Upgrading PanoPuppet has a few new steps now as user profiles and permissions has been implemented.
Now you should always run the following commands when updating PanoPuppet.
`python manage.py collectstatic`
`python manage.py makemigration`
`python manage.py syncdb`
If it doesnt apply any changes, that just means that no changes were done to the database for those latest commits.

## QueryBuilder notes
* I have seen some issues with the querybuilder and the usage of comparison operators. If you have stringify_facts enabled
you may not be able to use the less/less or equal/greater/greater or equal operators since its not possible to
compare string values "123" with "124". You will only be able to use the equal operator for these values.
* Some new changes implemented for the querybuilder has changed how it works.
To use the Querybuilder you must now be aware that resource queries in the same GROUP are all applied to the same group.
if you want to do two different resource queries you must add a new group and put in there.
It provides more flexibility to the querybuilder since you are able to specify which equality operator you want for
each "filter".

See the below examples:

![Querybuilder Example Query 1](screenshots/querybuilder_example.png)

![Querybuilder Example Query 2](screenshots/querybuilder_example2.png)

## LDAP Permissions
If you have enabled Permissions on users via the config file `ENABLE_PERMISSIONS: true`
By default no normal user (user that is not superuser or staff) will be able to see any servers
found in PuppetDB.
You must then go to the django admin page `http://<panopuppet-URL>/puppetadmin`, log in as a staff or superuser and add the users
group into the `Ldap group permissionss` table.
The whole CN for the group must be specified.
`cn=puppetusers,ou=groups,dc=example,dc=com`
You must also specify a PuppetDB query which will be appended to all queries made.
The query must use subqueries as it must be able to support all endpoints.
It is highly recommened to use the puppetdb query and generate the query you want to apply.

When the user logs in he or she will only be able to see the results of the puppetdb query you specified for that group.

### Superuser and staff groups
It is possible to make sure that all users in a specific group are allowed to log in to the admin page and see all nodes
by using the two below config options:
LDAP_SUPERUSER_GRP: 'cn=superuser,ou=groups,dc=example,dc=com'
LDAP_STAFF_GRP:
  - 'cn=staff,ou=groups,dc=example,dc=com'
  - 'cn=admin,ou=groups,dc=example,dc=com'

You can specify them as a normal string or by specifying them as a list.

### Member of Multiple Groups
If a user is a member of multiple groups which have restrictions set for each one
each rule found will be added in an puppetDB  OR operator, like so. `["and", ["or", [rule1],[rule2]]]`

## Configuration Options
NODES_DEFAULT_FACTS - Is a list of facts to be shown on the node report page.
                      Default value is: ['operatingsystem', 'operatingsystemrelease', 'puppetversion', 'kernel', 'kernelrelease', 'ipaddress', 'uptime']

## Available branches
The master branch has a release which includes:
* ldap authentication
* caching

## Contact Me
The best place to contact me for direct and personal support is at Gitter.
You can find the Gitter badge at the top of this README.

You can also find me at chat.freenode.net #panopuppet. I would however recommend Gitter over IRC, chat history, etc)

If all prevail and I don't answer you, create an issue.

## Development Server
Django runserver...

repository: jeroenzeegers/panopuppet

gha_language: Python

repo_name: jeroenzeegers/panopuppet


text:
# OpenTracing with Jaeger/Grafana using ChronoWave as storage backend
   * *Single node* mode [ChronoWave](https://github.com/chronowave/chronowave) as Jaeger storage backend.
   * Ad hoc query through Grafana *Explore* UI.

## Getting started

```
curl -O -L "https://raw.githubusercontent.com/chronowave/opentelemetry/main/docker-compose/docker-compose.yaml"
docker-componse up
```
Jaeger UI is at http://localhost:16686, Grafana UI is at http://localhost:3000

   * Optional: start [Jaeger Hot R.O.D](https://github.com/jaegertracing/jaeger/tree/master/examples/hotrod)

## ChronoWave features
1. supports keyword and wild card UTF-8 character search. For instance, if the input is `db.statement="User"` in *Tags* search field, the results will contain spans have at least one tag field where `key=db.statment` and `value` has word `User` (case sensitive) in it.
2. requires less system resources to store/process/query span. Spans are stored on disk and loaded into memory on demand.
3. supports ad hoc query through Grafana *Explore* with SSQL
4. the limit of nested tags/logs field is 65536 per span

## SSQL
   * [Introduction](https://github.com/chronowave/chronowave/wiki/Semi-Structured-Query-Language)

## How it works

### high level architecture
```text
   ┌────┐      ┌────Container───┐
   │┌───┴┐     │┌──────────────┐│
───┴┤┌───┴┬────▶│    Jaeger    ││
    └┤span│    │└───────▲──────┘│
     └────┘    │  plugin│       │
               │  ┌─────▼────┐.─. ad hoc query ───────┐
               │  │ChronoWave(   )◀──────────▶│Grafana│
               │  └─────▲────┘`─'             └───────┘
               └───────┬┴───────┘
                    ┌──▼────┐
                    │ /index│
                    │ /wal  │
                    │ db    │
                    └─host──┘
```
### collecting spans
1. Jaeger collector forwards spans to storage backend through gRPC plugin. ChronoWave marshals span into [ElasticSearch document model](https://github.com/jaegertracing/jaeger/blob/master/plugin/storage/es/spanstore/dbmodel/model.go), saves JSON files in `wal` directory.
   * Note: ChronoWave is a schema agnostic data store.
2. construct self-compressed indices. ChronoWave has two timer tasks
   * Near time. Build index with all files in `wal` directory.
   * On Demand. Build long term index in `index` directory and remove indexed files from `wal` directory.
3. create secondary index:

   | JSON path   | Type |  SSQL syntax | Description |
   | ----------- | ---------- | ----------- | ----------- |
   | /startTime  | timestamp  | `[$ts /startTime timeframe(from, to)]` | timestamp in microsecond, used for time range query |
   | /traceID    | key        | `[$tid /traceID key('2020')]` | string value, used as key lookup |
   | /spanID     | key        | `[$sid /spanID key('2020')]` | string value, used as key lookup |

### Using Jaeger UI

1. query has time range.
   * look up timestamp secondary index to find all index files in the range.
   * scatter queries to all available CPUs and gather the result
2. query by key, ie traceID or spanID.
   * look up key secondary index to find all index files contains the value.
   * scatter queries to all available CPUs and gather the result

### Ad Hoc query using Grafana Explore

The timestamp field should be `/startTime`. *Note: timestamp in Jaeger span recorded as microsecond*
The following screen shot is the result of query
 ```
find $tid, $log where [/logs/fields/value contain('nearby')] [$tid /traceID] [$log /logs]
```
The query is to list spans' traceID and logs if one of the log field contains word "nearby". ChronoWave Grafana backend datasource plugin adds time range in request before forwarding the query.
Please refer to Jaeger ElasticSearch db model (below) for supported path in SSQL query.

![alt text](./images/explore.png "Grafana Explore")

## Reference

[ElasticSearch document model](https://github.com/jaegertracing/jaeger/blob/master/plugin/storage/es/spanstore/dbmodel/model.go)

```go
// Span is ES database representation of the domain span.
type Span struct {
	TraceID       TraceID     `json:"traceID"`
	SpanID        SpanID      `json:"spanID"`
	ParentSpanID  SpanID      `json:"parentSpanID,omitempty"` // deprecated
	Flags         uint32      `json:"flags,omitempty"`
	OperationName string      `json:"operationName"`
	References    []Reference `json:"references"`
	StartTime     uint64      `json:"startTime"` // microseconds since Unix epoch
	// ElasticSearch does not support a UNIX Epoch timestamp in microseconds,
	// so Jaeger maps StartTime to a 'long' type. This extra StartTimeMillis field
	// works around this issue, enabling timerange queries.
	StartTimeMillis uint64     `json:"startTimeMillis"`
	Duration        uint64     `json:"duration"` // microseconds
	Tags            []KeyValue `json:"tags"`
	// Alternative representation of tags for better kibana support
	Tag     map[string]interface{} `json:"tag,omitempty"`
	Logs    []Log                  `json:"logs"`
	Process Process                `json:"process,omitempty"`
}

// Reference is a reference from one span to another
type Reference struct {
	RefType ReferenceType `json:"refType"`
	TraceID TraceID       `json:"traceID"`
	SpanID  SpanID        `json:"spanID"`
}

// Process is the process emitting a set of spans
type Process struct {
	ServiceName string     `json:"serviceName"`
	Tags        []KeyValue `json:"tags"`
	// Alternative representation of tags for better kibana support
	Tag map[string]interface{} `json:"tag,omitempty"`
}

// Log is a log emitted in a span
type Log struct {
	Timestamp uint64     `json:"timestamp"`
	Fields    []KeyValue `json:"fields"`
}

// KeyValue is a key-value pair with typed value.
type KeyValue struct {
	Key   string      `json:"key"`
	Type  ValueType   `json:"type,omitempty"`
	Value interface{} `json:"value"`
}

// Service is the JSON struct for service:operation documents in ElasticSearch
type Service struct {
	ServiceName   string `json:"serviceName"`
	OperationName string `json:"operationName"`
}
```

repository: chronowave/opentelemetry

repo_name: chronowave/opentelemetry


text:
---
title: "Speakup"
date: "2016-06-21"
description: "Speakup, written by Kirk Reiser and Andy Berdan, is a screen review package for the Linux operating system."
type: "Software"
tags: ['Text to Speech','Other function','Viewing the screen' ]
image: "images/full/3.png"
thumb: "images/thumbs/3.png"
project_url: ""
download_url: "http://www.linux-speakup.org/download.html"
---
From the authors:
-----------------

 Speakup allows you to interact with applications and the GNU/Linux operating system with audible feedback from the console using a synthetic speech device.

 Speakup is licensed under the GPL; the GNU General Public License.

 Speakup allows you to navigate around the screen using the typical screen review functions such as say word, say line, announce cursor position, which console your currently on, and much, much more. It also allows one to load in configuration parameters for controlling various aspects of the synthesizer you are using, as well as speakup itself. You can review the current default key assignments here.

### Links:
- <a<EMAIL_ADDRESS>Address
- Project Home Page

### Download: http://www.linux-speakup.org/download.html


text:
# Visualizing and Clustering 1.3M neurons, with optimizations

## Speeding up Nearest Neighbors and UMAP with CPU parallelization

We will use a machine on Google Cloud Platform.

You may wish to change the zone specified here:

```bash
export IMAGE_FAMILY="ubuntu-1804-lts"
export ZONE="us-central1-a"
export INSTANCE_NAME="$USER-scanpy"

gcloud compute instances create $INSTANCE_NAME \
  --zone=$ZONE \
  --image-family=$IMAGE_FAMILY \
  --image-project=ubuntu-os-cloud \
  --machine-type=n1-highmem-32 \
  --subnet=default \
  --network-tier=PREMIUM \
  --maintenance-policy=TERMINATE
```

Connect to the instance with the following command. Note that it may
take a few minutes before it is ready to accept connections.

```bash
gcloud compute ssh --zone $ZONE $INSTANCE_NAME
```

Install Python and other packages:

```bash
sudo apt-get update && sudo apt-get install -y git python3-pip python3-tk
```

Install louvain:

```bash
sudo apt-get install -y libz-dev libxml2-dev && pip3 install --user louvain # takes a while to install from source
```

Install scanpy with parallel optimization (not yet merged, or released)

```bash
pip3 install setuptools_scm
git clone https://github.com/tomwhite/scanpy
(cd scanpy; git checkout -b umap_embedding_optimization_0.4dev origin/umap_embedding_optimization_0.4dev; pip3 install -e .)
```

Install umap 0.4dev with parallel optimization (not yet released)

```bash
pip3 uninstall -y umap-learn
pip3 install<EMAIL_ADDRESS>```

Install pynndescent so that NN can run in multiple threads

```bash
pip3 install git+https://github.com/lmcinnes/pynndescent
```

Update various python packages to fix numba warnings:

```bash
pip3 install colorama>=0.3.9
```

Checkout this repo in the instance to give access to the scripts.

```bash
git clone https://github.com/theislab/scanpy_usage
cd scdata_usage/191113_umap_parallel
```

Copy test data to the instance. Note that you will have to change the user
(`-u`) to be your GCP project since the data is in a requester pays bucket.

```bash
gsutil -u hca-scale cp gs://ll-sc-scdata/10x/1M_neurons_filtered_gene_bc_matrices_h5.h5 1M_neurons_filtered_gene_bc_matrices_h5.h5
```

Run the analysis (optimized):

```bash
python3 cluster_130K_opt.py 1M_neurons_filtered_gene_bc_matrices_h5.h5
```

Run the analysis (optimized) on 1M cells:

```bash
python3 cluster_opt.py 1M_neurons_filtered_gene_bc_matrices_h5.h5
```

Install regular scanpy and umap 0.3:

```bash
pip3 uninstall -y scanpy umap-learn
pip3 install scanpy==1.4.4.post1
pip3 install git+https://github.com/lmcinnes/umap # fix warnings (not in umap 0.3.10)
```

Run the analysis (regular):

```bash
python3 cluster_130K.py 1M_neurons_filtered_gene_bc_matrices_h5.h5
```

Run the analysis (regular) on 1M cells:

```bash
python3 cluster.py 1M_neurons_filtered_gene_bc_matrices_h5.h5
```

_Summary: unoptimized UMAP takes 3:39 minutes,
optimized takes 1:24 minutes on 130K cells;
unoptimized UMAP takes 59 minutes,
optimized takes 22 minutes on 1M cells._

To view the figures, run the following from your local machine to copy
them locally:

```bash
gcloud compute scp --zone $ZONE --recurse $INSTANCE_NAME:scdata_usage/191113_umap_parallel/figures figures
```

## Finishing up

```bash
gcloud compute instances delete --zone $ZONE --quiet $INSTANCE_NAME
```

repository: das-projects/singlecell

repo_name: das-projects/singlecell


text:
A test helper that creates a mock crash reporter service which responds
based on a caller-provided function.

## Usage

### BUILD.gn
Nothing special, other than including this crate:

```
  deps = [
    "//src/sys/pkg/testing/mock-crash-reporter:lib",
  ]
```

### In tests
See the tests in `src/lib.rs` for examples of using this crate in various scenarios,
including making file calls succeed, fail, or act on external data.

repository: gnoliyil/fuchsia

repo_name: gnoliyil/fuchsia


text:
textile
=======

Textile Merge Library

The textile merge library supplements other merge software such as
diff3.  It is capable of performing 3-way merges in many cases where
changes are made on both sides within the same line.

Textile uses an algorithm to find the longest common subsequence (LCS)
between the base and each of the derived files.  It then uses the two
to perform the three-way merge.  When the merge is successful, it
calls a callback provided by the caller.  The caller provides a
similar callback to handle conflicting changes.

The LCS algorithm is very CPU and memory intensive.  It is O(mn) for
both time and space where m and n are the lengths of the sequences.
Some extra effort is made to find the LCS with the least amount of
fragmention.  In other words, the matching parts of the LCS are
consecutive as much as possible.  This doesn't change the algorithm
complexity but does double the amount of memory used and increases the
runtime similarly.

Because of the demands on time and memory, this library is only useful
for resolving smaller conflicts.  It is expected that the caller will
do the heavy lifting by doing most of the merge using traditional line
based merge techniques and use this library as a second pass over the
conflicts.

This library is experimental for now.  I imagine that it will take
some time to get experience with it.  For now, I have created a patch
to diffutils to run the algorithm when --inline-merge is passed.  I
call it from a custom git mergetool script to post process merge
conflicts.  For now, I wish to keep an eye on it.

repository: ecbaldwin/textile

repo_name: ecbaldwin/textile


text:
---
layout: kanji
v4: 905
v6: 971
kanji: 称
keyword: appellation
elements: appellation, wheat, cereal, hammock, reclining, lying down, small, little
strokes: 10
image: E7A7B0
on-yomi: ショウ
kun-yomi: たた.える、とな.える、あ.げる、かな.う、はか.り、はか.る、ほめ.る
permalink: /rtk/称/
prev: 秘
next: 利
---

1) [wrightak] 16-5-2006(224): Taking appellation to mean the act of naming, we have the little baby superman reclining in the space craft that landed in a wheat field.  (I also thought of Jesus but he was born in a barn full of hay not wheat).

2) [the_marshal] 17-1-2007(119): WHEAT that is RECLINING and LITTLE (small) can't get the APPELLATION "quality wheat".

3) [Katsuo] 3-11-2007(87): An Indian chief explains the art of appellation by introducing his three children: Swaying Wheat, Reclining Buffalo and Little Bear.

4) [Stormchild] 18-7-2006(47): The way this wheat reclines a little justifies its appellation: "lazy wheat".

5) [igordesu] 5-1-2009(24): If you're having trouble thinking of a name for your little one, go lie down in a field of wheat for a while and gaze at the stars.


text:
# Xenochalara M.J. Wingf. & Crous GENUS

#### Status
ACCEPTED

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
S. Afr. J. Bot. 66(2): 101 (2000)

#### Original name
Xenochalara M.J. Wingf. & Crous

### Remarks
null


text:
# Freezed-Process-Killer

Kill your processes if their it's not responding.

## 🚀 Starting

### 📋 Pre-requisite

All You will need:

```
Visual Studio 2019 Community
Install Compiler C# on VS
```

### ⚙ Configuration

How Configure to kill your process:

Process(PID or Name): You need the process id or process name, you can get in task manager, example:
```
Process(PID or Name): Chrome
```

Check Delay(ms): The delay of check the process, verify if process not responding, in milliseconds, example:
```
Check Delay(ms): 1000
```

Confirmation Number(to kill a process): The number of confirmations that will need to kill a process, example:
```
Confirmation Number(to kill a process): 3 //will check 3 times in 1000ms = 1s
```

### 🖼 Screenshots

![alt text](https://github.com/MateusWC/Freezed-Process-Killer/blob/main/images/img1.png)

![alt text](https://github.com/MateusWC/Freezed-Process-Killer/blob/main/images/img2.png)

![alt text](https://github.com/MateusWC/Freezed-Process-Killer/blob/main/images/img3.png)

## 🛠 Framework Used

* [Bunifu Framework](https://bunifuframework.com/)

## ✒ Author

* **MateusWC** - [Profile](https://github.com/MateusWC)

## 📄 Licence

This Project is under licence - Licence File: [LICENSE.md](https://github.com/MateusWC/Freezed-Process-Killer/blob/main/LICENSE)

repository: MateusWC/Freezed-Process-Killer

repo_name: MateusWC/Freezed-Process-Killer


text:
The term modern art sounds like it
means art that is popular at the moment,
but in fact, modern art is a style
that originated over 150 years ago,
and includes artists that by now
have attained classic status,
such as Picasso, Matisse, and Gauguin.
And what's even more ironic is that
the movement they pioneered,
considered revolutionary
and even scandalous at the time,
was inspired largely by an object
of a traditional and ancient design.
As far back as the Renaissance,
the primary European art movements
emphasized conventional representation
and adherence to classical forms.
But that began to change
in the late 19th century
as artists like Van Gogh and Cézanne
expanded the boundaries of painting.
Soon, a movement arose that sought
to create an entirely new style of art,
and one way of doing so was to look
beyond Western civilization.
For example, Paul Gauguin moved
to the island of Tahiti in the 1890s.
There, he found inspiration in the island's
inhabitants, landscape, and culture
to create artwork that intertwined
European themes and Polynesian lore.
Others looked the cultures
of the Islamic world,
but the most influential inspiration
would come from Sub-Saharan Africa.
As European empires expanded
deeper into the African continent,
its artifacts and artworks made their way
into the hands of museums and collectors.
One such collector was Henri Matisse,
who showed his friend Picasso
a mask he had acquired
made by the Dan tribe of the Ivory Coast.
The mask awoke Picasso's curiosity,
leading him to visit the Trocadéro
Ethnographic Museum in Paris in 1907.
Founded to house acquisitions
from colonial conquests,
the museum boasted
a collection of African art,
with stylized figures
and masks made of wood
and decorated with simple colors
and materials.
The visit was a revelation for Picasso,
who proclaimed that African masks
were what painting was all about.
At this time, Picasso had been working
on a painting of five nude women
in a style that would later come
to be known as Cubism.
And while three of these ladies
show facial features
found in ancient Iberian art,
a nod to Picasso's Spanish heritage,
the faces of the two on the right
closely resemble African masks.
Created in 1907 after hundreds
of sketches and studies,
"Les Demoiselles d'Avignon"
has been considered
the first truly 20th century masterpiece,
breaking with many previously
held notions in art.
It was at once aggressive and abstract,
distorted yet primal in its raw geometry,
a new artistic language with new forms,
colors, and meanings.
And these avant-garde qualities
caused a sensation
when the painting was first exhibited
almost ten years later.
The public was shocked,
critics denounced it as immoral,
and even Picasso's own friends
were simultaneously surprised,
offended,
and mesmerized at his audacity.
More artists soon followed
in Picasso's footsteps.
Constantin Brâncuși
and Amedeo Modigliani in Paris,
as well as the German Expressionists,
all drew on the aesthetics
of African sculptures in their work.
Others looked to a different continent
for their inspiration.
British sculptor Henry Moore based many
of his semi-abstract bronze sculptures
on a replica of a chacmool,
a distinctive reclining statue
from the Toltec-Maya culture.
Pre-Columbian art was also a major
influence for Josef Albers.
He created a series of compositions,
such as the geometrical series
Homage to the Square,
that were inspired by pyramids
and local art
he encountered
on his frequent visits to Mexico.
Inspiration from ancient cultures
initiated one of the most revolutionary
movements in art history,
but were these artists playing the role
of explorers or conquistadors,
appropriating ideas and profiting
from cultures they considered primitive?
Questions like this deserve scrutiny,
as artists continue to redefine standards.
Perhaps not too long from now,
the bold innovations of modern art
will seem like stale orthodoxies,
ready to be overturned by a new set
of radical trailblazers
drawing inspiration from another
unlikely source.

repository: prewittdavon/TEDVis

repo_name: prewittdavon/TEDVis


text:
---
title: Table of contents
toc_type: overview
---

# Table of contents

TOC makes it possible to structure a website globally, without having to manually define a list of entries. The tree is constructed by an alphabetical order of the source files.

{% TOC mode:current depth:-1 %}


text:
# Gabo.RetryHelper

Gabo.RetryHelper is my first project and it's intended to provide help when you need to retry some action until no exception is thrown. The max ammount of retries can be configured as well as the time it should wait between tries.

## Usage
### Important Note
RetryHelper will throw the original exception if it fails for the maximum retries, so you should always surround it by a try/catch clause.

### Basic Scenario
```csharp
    var a = 1;
    RetryHelper.Try(() => {
        a++;
    });
```
### Full Example
```csharp
    try{
        int maxTries = 7; // default is 5
        int sleepMilliseconds = 500; //default is 100

        RetryHelper.Try(()=>{
                doSomeWork();
            }, maxTries, sleepMilliseconds);
        );
    }
    catch(Exception ex)
    {
        //here you can catch an exception that was thrown by doSomeWork() method if it was
        // thrown more times than the max of tries setted up.
    }
```

repository: Gabriel-Espinoza/RetryHelper

repo_name: Gabriel-Espinoza/RetryHelper


text:
## getUtteranceBeforeNode.py
This tool extracts user utterances from Watson Assistant logs.
The purpose of this tool is to find user utterances containing intents that can be analyzed further.

Given a list of intent-based utterances it is possible to
Test accuracy: Create a "blind" test file by adding a column with a "golden intent" for each utterance, then running WA-Testing-Tool in blind mode.
Improve training: Inspect utterances for new intents/entities that may need to be added.

*Prerequisite steps*

Gather the information needed to connect to your workspace (apikey, URL, and workspace ID)

Gather the node ID to analyze.  For each conversation that hits this node you will get the user utterance directly before this node fired.

*Execution steps*

You are required to provide:
* Arguments to connect to your workspace (apikey `-a`, workspace_id `-w`, and optionally url `-l`)

You may optionally provide
* A node ID to analyze (node_ID `-n`, default is `anything_else`)
* Output type (columns `-c`, `raw`, `all` or `utterance`, default is `utterance`, raw prints out JSON log and other modes print tab-separated output)
* Output filename (file `-o`, default is to print to screen)
* Maximum results (page limit `-p`, default is 100)

Example execution:

```
python3 getUtteranceBeforeNode.py -n node_1_1234567890123 -a<PHONE_NUMBER>334444555566667777888899990000 -w 11111111-2222-3333-4444-555566667777 -l https://gateway-wdc.watsonplatform.net/assistant/api -c all -o output.tsv
```

You can print the help using the following command:

```
python3 getUtteranceBeforeNode.py -h
```


text:
# GUT_Mobile-Applications
Mobile app project for GUT classes, representing communication between mobile app and server (with focus on data synchronization).
Currently added after-offline sync feature with conflits resolving.

Used technologies:
===
Whole project was created using [Microsoft Azure Mobile Service](https://azure.microsoft.com/en-us/services/app-service/mobile/) and it's backend is hosted in cloud.

* *Client side* (Mobile App) is working under Windows Phone 8.1 SDK
* *Server side* (Backend) is working using .NET Backend (.NET MVC API & Mobile Service API hybrid)

Next Steps:
===
1. Coming up with creative way of API versioning in respect to /tables/ endpoint in Mobile App


text:
% Rudin 7.13
% John Lekberg

# Statement

Assume that $\seq{f_n}$ is a sequence of monotonically increasings functions on $\real{1}$ with $0\leq f_n(x) \leq 1$ for all $x$ and all $n$.

(a) Prove that there is a function $f$ and a sequence $\seq{n_k}$ such that
$$
f(x) = \lim_{k\to\infty}f_{n_k}(x)
$$
for every $x\in\real{1}$.
(The existence of such a pointwise convergent subsequence is usally called *Helly's Selection Theorem.*)
(b) If, moreover, $f$ is continuous, prove that $f_{n_k}\to f$ uniformly on compact sets.
    *Hint*:
    (i) Some subsequence $\seq{f_{n_i}}$ converges at all rational points $r$, say, to $f(r)$.
    (ii) Define $f(x)$, for any $x\in\real{1}$, to be $\sup f(r)$, the sup being taken over all $r \leq x$.
    (iii) Show that $f_{n_i}(x)\to f(x)$ at every $x$ at which $f$ is continuous.
    (This is where monotonicity is strongly used.)
    (iv) A subsequence of $\seq{f_{n_i}}$ converges at every point of discontinuity of $f$ since that are at most countably many such points.
    This proves (a).
    To prove (b), modify your proof of (iii) appropriately.

# Solution

license: Unlicense

repository: xyanglian/rudin-analysis

repo_name: xyanglian/rudin-analysis


text:
# Running Playwright in Docker

[Dockerfile.bionic](Dockerfile.bionic) is a playwright-ready image of playwright.
This image includes all the dependencies needed to run browsers in a Docker
container.

Building image:

```
$ sudo docker build -t microsoft/playwright:bionic -f Dockerfile.bionic .
```

Running image:

```
$ sudo docker container run -it --rm --ipc=host --security-opt seccomp=chrome.json microsoft/playwright:bionic /bin/bash
```

> **NOTE**: The seccomp profile is coming from Jessie Frazelle. It's needed
> to run Chrome without sandbox.
> Using `--ipc=host` is also recommended when using Chrome. Without it Chrome can run out of memory and crash.
> [See the docker documentation for this option here.](https://docs.docker.com/engine/reference/run/#ipc-settings---ipc)

repository: smartrejames/playwright

repo_name: smartrejames/playwright


text:
{
"title"       : "Error Code Directory",
"sort"        : "50",
"category"    : "Getting Started",
"description" : "Getting Started",
"date_published" : "2018-03-18T08:00:00+08:00",
"date_modified"  : "2018-03-18T08:00:00+08:00"
}

---%

### Error Codes and their definitions:

* ERROR_0 :  Please enter a valid amount.

* ERROR_1 :  Your password must be at least 9 characters. Please ensure it is a strong password.

* ERROR_2 :  Sorry! We don't recognize this type of wallet file.

* ERROR_3 :  This is not a valid wallet file.

* ERROR_4 :  This unit doesn't exists, please use the one of the following units.

* ERROR_5 :  Please enter a valid address.

* ERROR_6 :  Please enter a valid password.

* ERROR_7 :  Please enter valid decimals (Must be an integer. Try 0-18.).

* ERROR_8 :  Please enter a valid gas limit (Must be an integer. Try 21000-4000000.).

* ERROR_9 :  Please enter a valid data value (Must be hex.).

* ERROR_10 :  Please enter a valid gas price (Must be an integer. Try 20 GWEI /<PHONE_NUMBER>0 WEI.).

* ERROR_11 :  Please enter a valid nonce (Must be an integer.).

* ERROR_12 :  Invalid signed transaction.

* ERROR_13 :  A wallet with this nickname already exists.

* ERROR_14 :  Wallet not found.

* ERROR_15 :  Whoops. It doesn't look like a proposal with this ID exists yet or there is an error reading this proposal.

* ERROR_16 :  A wallet with this address already exists in storage. Please check your wallets page.

* ERROR_17 :  Insufficient balance. Your gas limit * gas price + amount to send exceeds your current balance. Send more ETH to your account or use the "Send Entire Balance" button. If you believe this is in error, try pressing generate again. Required (d+) and got: (d+). [Learn More.](https://support.mycrypto.com/transactions/transactions-not-showing-or-pending.html).

* ERROR_18 :  All gas would be used on this transaction. This means you have already voted on this proposal or the debate period has ended.

* ERROR_19 :  Please enter a valid symbol.

* ERROR_20 :  Not a valid ERC-20 token.

* ERROR_21 :  Could not estimate gas. There are not enough funds in the account, or the receiving contract address would throw an error. Feel free to manually set the gas and proceed. The error message upon sending may be more informative.

* ERROR_22 :  Please enter a valid node name.

* ERROR_23 :  Please enter a valid URL. If you are on https, your URL must be https.

* ERROR_24 :  Please enter a valid port.

* ERROR_25 :  Please enter a valid chain ID.

* ERROR_26 :  Please enter a valid ABI.

* ERROR_27 :  Minimum amount: 0.01. Max amount:.

* ERROR_28 :  You need this `Keystore File + Password` or the `Private Key` (next page) to access this wallet in the future.

* ERROR_29 :  Please enter a valid user and password.

* ERROR_30 :  Please enter a valid name (7+ characters, limited punctuation).

* ERROR_31 :  Please enter a valid secret phrase.

* ERROR_32 :  Could not connect to the node. Refresh your page, try a different node (top-right corner), check your firewall settings. If custom node, check your configs.

* ERROR_33 :  The wallet you have unlocked does not match the owner's address.

* ERROR_34 :  The name you are attempting to reveal does not match the name you have entered.

* ERROR_35 :  Input address is not checksummed. [This is an explanation of checksummed addresses](https://support.mycrypto.com/send/not-checksummed-shows-when-i-enter-an-address.html).

* ERROR_36 :  Please enter a valid TX hash.

* ERROR_37 :  Please enter valid hex string. Hex only contains: 0x, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, a, b, c, d, e, f

* ERROR_38 :  Offer must have either price or reserve set to more than 0.

* ERROR_39 :  Bid must be more than the specified minimum.

###### As an alternative to this, you can navigate to [this github repository](https://github.com/MyCryptoHQ/mycrypto.com/blob/master/app/scripts/translations/en.js) and use CTRL+F to search for an error code or search term.


text:
<img src="man/figures/logo_naturaList_2.png" alt="naturaList logo" width="120px" align="right"/>

# naturaList

<!-- badges: start -->

[![CRAN\_Status\_Badge](https://www.r-pkg.org/badges/version/naturaList)](https://cran.r-project.org/package=naturaList) [![R-CMD-check](https://github.com/avrodrigues/naturaList/workflows/R-CMD-check/badge.svg)](https://github.com/avrodrigues/naturaList/actions)
[![metacran downloads](https://cranlogs.r-pkg.org/badges/grand-total/naturaList)](https://cran.r-project.org/package=naturaList)
[![metacran downloads](https://cranlogs.r-pkg.org/badges/naturaList)](https://cran.r-project.org/package=naturaList)

<!-- badges: end -->

The goal of the `{naturaList}` package is providing tools for checking the identification reliability in species occurrence datasets. The main functionality of the `{naturaList}` package is providing an automated way to identify for the taxon of interest, which records has the most reliable level of classification, i.e, those records identified by specialists. In addition other characteristics of the records could be used to derive up to six levels of confidence.

## Installation
You can install the package from CRAN:
``` {.r}
install.packages("naturaList")
```

Or install the latest released development version from github using:

``` {.r}
install.packages("devtools")
devtools::install_github("avrodrigues/naturaList")
```

## Levels of confidence

The package allows to classify the occurrence records in confidence levels through the function `classify_occ()`, that comprises the main function of naturaList package. The most reliable identification of a specimen is made by a specialist in the taxa. The other levels are derived from information contained in the occurrence dataset. The default order of confidence levels used in classification process are:

-   Level 1 - species was identified by a specialist, if not;
-   Level 2 - who identified the species was not a specialist name, if not;
-   Level 3 - occurrence record has an image associated, if not;
-   Level 4 - the specimen is preserved in a scientific collection, if not;
-   Level 5 - the identification was done in filed observation, if not;
-   Level 6 - no criteria was met.

The user can alter this order, depending on his/her objectives, except for the Level 1 that is always a species determined by a specialist.

## Basics of naturaList package

An extensive explanation of all the features of naturaList package is provided through [vignette articles](https://avrodrigues.github.io/naturaList/articles/natutaList_vignette.html). To conduct a basic classification process through `classify_occ` function the user must provide only two data frames. The first containing the occurrence records and the second with a list of specialists. The `classify_occ()` function add a new column in the occurrences dataset named `naturaList_levels`, which contains the classification.

``` {.r}
library(naturaList)
data("A.setosa")
data("speciaLists")

occ.cl <- classify_occ(A.setosa, speciaLists)
```

Naturalist also offer an interactive module that allows to visualize occurrence in space, get information by pointing the occurrence of interest and manually edit occurrence records by point and click. This interactive module is activate through function `map_module`. An article explaining all features of `map_module` function can be accessed in this [article](https://avrodrigues.github.io/naturaList/articles/naturaList_map_module_vignette.html)

## Other resources

Auxiliary functions that allows the user to access the effects of filtering procedures based on classification levels are `clean_eval` and `grid_filter` functions. A complete example of the usage of these functions can be found in this [article](https://avrodrigues.github.io/naturaList/articles/natutaList_clean_eval_vignette.html).

See [vignette](https://avrodrigues.github.io/naturaList/articles/natutaList_vignette.html) for all articles describing the functionalities of naturaList package.

repository: avrodrigues/naturaList

gha_language: R

repo_name: avrodrigues/naturaList


text:
# Ragu

## Dependencies

* 1 large onion
* 2 sticks celery
* 2 carrots finely chopped
* mince
* 1 jar passata
* 1.5 litres chicken stock
* tomato paste.
* salt and pepper

## Method

Fry gently in large saucepan with a teaspoon or two of oregano. Add mince, jar passata, 1 1/2 litres chicken stock, salt and pepper, good squeeze tomato paste.

Put lid mostly on and leave popping on a low heat for 2 hours

repository: RichTeaMan/food

repo_name: RichTeaMan/food


text:
# dump

Dump at a certain position.

## arguments

`arg1` The address to dump at.

## result

This command does not set any result variables.


text:
# dockerdevenv

Base Docker image for making a dev environment you can remote into.

## User Guide

Run the container exposing port 22 and mounting your public key as
/root/.ssh/authorized_keys.

repository: fffergal/dockerdevenv

repo_name: fffergal/dockerdevenv


text:
# Gridworld Problem

Uses the Gridworld class for implementing the gridworld problem.

The gridworld problem refers to a task where a 2D grid is provided and a player
can explore the grid. The objective of the task is to obtain as many points as
possible by performing actions on the grid that provide rewards to the player.
These rewards are part of the definition of the grid.

Currently implemented methods for solving the gridworld problem include
value iteration and policy iteration.

Based on Chapter 3 of Reinforcement Learning: An Introduction, second edition,
by Sutton and Barto.


text:
# CDLU Mathematics Hub

CDLU Mathematics Hub is an Android application developed in Java using Android Studio. It's developed by Paras Sidhu for Chaudhary DeviLal University (CDLU) situated in Sirsa, Haryana, India. This application uses Google's Material Design which makes it visually appealing.

## Concepts

- Navigation Drawer with Fragments
- 4 Different Types of `RecyclerView` implementations
- File Download using Retrofit and show progress via Notifications
- Logical implementation of a typical TimeTable
- Dynamic Theming

[![Get it on Google Play](https://play.google.com/intl/en_us/badges/images/generic/en_badge_web_generic.png)](https://play.google.com/store/apps/details?id=com.parassidhu.cdlumaths)

**Note**: This is my very first Android app and thus contains code from the time I was learning more about Android Development. Due to this, the project contains bad coding practices (at very few places). I have improved the code quality over time but still there's some more work to do. PRs are most welcome to improve upon this.

## License

Copyright 2018, Paras Sidhu

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

repository: sidhuparas/CDLUMathematicsHub

gha_language: Java

repo_name: sidhuparas/CDLUMathematicsHub


text:
# Twitter Sentiment Analysis in Python
This project has an implementation of estimating the sentiment of a given tweet based on sentiment scores of terms in the tweet (sum of scores). The AFINN-111 list of pre-computed sentiment scores for English words/pharses is used.

## Derive sentiment of each tweet (tweet_sentiment.py)
This script prints to stdout the sentiment of each tweet in a given file, where the sentiment is computed by summing the sentiment scores of words/phares in the tweet taken from the AFINN-111 list, but if not present in the list it is given a sentiment score of 0.

The script can be executed using the following command:
```
python tweet_sentiment.py <sentiment_file> <tweet_file>
```
The tweet_file contains data formatted in the same way as the livestream data.

## Derive sentiment of new terms (term_sentiment.py)
This script computes the sentiment for terms that do not appear in the AFINN-111 list. The intuition is that once we use certain words/phrases to deduce the sentiment of a tweet, we can assign this sentiment score to other words in the tweet not present in the AFINN-111 list.

The script can be executed using the following command:
```
python term_sentiment.py <sentiment_file> <tweet_file>
```

## Which state is happiest in the U.S? (happiest_state.py)
This script determines the happiest state based on the sum total of the sentiment scores of the tweets originating from that state. The tweets are limited to the ones in the United States using the location information encoded with the tweet.

The script can be executed using the following command:
```
python happiest_state.py <sentiment_file> <tweet_file>
```

## Top ten hash tags (top_ten.py)
This script computes the ten most frequently occuring hash tags from the data in the tweet_file.

The script can be executed using the following command:
```
python top_ten.py <tweet_file>
```


text:
---
layout: post
---
This article shows you how to add applications to run on startup on Ubuntu.

I recently setup my jekyll blog at github. I am so happy with it. I decided to create a local blog too. It shall be my local notebook. I wanted it to run on startup in my machine. Set it as my homepage.

# Fire up Startup Applications
In the desktop--press the super button. This triggers the find menu of Ubuntu. Key in `Startup Applications`. Click on the icon to run the software.

![Find Startup Applications](/images/01.startup.applications.png)

# Add Startup Program

![Add Startup Program](/images/02.startup.command.png)

Click on the Add button. Fill in the details:

* Name:

`Run local blog`

* Command:

`sh -c "cd /path/to/application; jekyll serve"`

* Comment:

`This will run my local blog on http://localhost:4000`

*Finally click the Add button*

> The trick here is to call sh -c "commandline" to run the application properly


text:
DUO-Camera-ROS
==============

This package is a ROS stereo camera driver for DUO cameras.

The package can act as either a regular camera driver outputing a left and right camera image, or it can act purely as a stereo camera, outputing a disparity image, and a PointCloud2. The user is not limited to one or the other, both left/right camera images can be provided at the same time as disparity and PointCloud2.

This driver works ONLY with DUO3D (http://duo3d.com/) cameras.
Utilizing the optimized DUO Dense3D library, eliminates the need for other disparity calculation nodes.

There are two different nodes:

	- duo_node: 			Generic DUO Camera driver (Left/Right image data)
	- duo_dense3d_node: 	Stereo Camera driver using DUO Dense3D Library


text:
# Mudslide

A slow moving monotonically increasing mass of data.

_Mudslide_ is like a directory tree with pocket dimensions.
You store sets of files in it, and retrieve sets of files from it.
Common data is shared between file sets.

It's also a playground for trying out different programming languages,
so there are several implementations in here. This is not an application
ready for use anywhere.

## Running

See the README in each subdirectory in this repository.

They all have their own language appropriate build tools, no mono repo
build magic here.

## Usage

When running, all implementations serve this HTTP API for storing and
retrieving files and file sets (described by "manifests"):

    PUT /api/files/:checksum
    GET /api/files/:checksum

    PUT /api/manifests/:checksum
    GET /api/manifests/:checksum
    GET /api/manifests/

A file is any sequence of bytes. A manifest is a text file describing a
set of stored files. See [#Protocol].

## Protocol

In _Mudslide_ there are files and manifests. Files are just binary data.
Manifests describe sets of named files. Files and manifests can only be added.
Nothing can be changed or deleted.

All checksums are 40 character lower case hexadecimal sha1.

### Files

Files when stored do not have a name other than their checksum. The only way
to name files is by writing a manifest (see below).

### Manifests

(Inspired by [Fossil]])

A Manifest defines a set of files that have been stored. A manifest contains a
list file checksums with filenames,  as well as a checksum for the manifest
itself. The manifest checksum is also the name of the manifest.

The manifest is utf-8 text. A manifest consists of one or more "cards"
separated by a single newline (ASCII: 0x0a) character. Each card begins with a
single character "card type". Zero or more arguments may follow the card type.
All arguments are separated from each other and from the card-type character
by a space character. There is no surplus white space between arguments
and no leading or trailing whitespace except for the newline character that
acts as the card separator. All cards must be in strict lexicographical order.
There may not be any duplicate cards. No card can contain newline characters.

    F file-checksum filename
    Z manifest-checksum

A manifest has one or more F cards. Each F card identifies a file that has
been stored. The card has two arguments. The first argument is the checksum
of the file content. The second argument is the pathname of the file.
No ".." or "." directories are allowed within the filename. Backslash
characters and newlines are not allowed within filenames.

A manifest must have a single Z card as its last line. The argument to the Z
card is the checksum of all prior lines of the manifest up to and including
the newline character that immediately precedes the "Z".

[Fossil]: https://www.fossil-scm.org/

## Pretend Backlog

- simple gossip protocol to let different servers cooperate storing and serving data
- more implementations: Go, Rust, C, Pony, Kotlin, Rebol ... the sky is the limit
- "manyfests", describing a set of manifests together
  - has `M checksum logical-name` cards and a `Z checksum` card only
  - not recursive, just one level of wrapping
- comments in manifests ("C cards")
  - would lead to possibly duplicate manifests with regards to file contents
- chunking files when storing
  - Park, KyoungSoo & Ihm, Sunghwan & Bowman, Mic & Pai, Vivek. (2007). Supporting Practical Content-Addressable Caching with CZIP Compression.

repository: fabjan/mudslide

repo_name: fabjan/mudslide


text:
<!--- Do what's ask in these balise, you don't need to erase them -->
<!--- Provide a general summary of the issue in the Title above -->

<!---
It's REALLY important to first look if your issue isn't already solved or reported.
To do that, go to https://github.com/Leviathan-Studio/CraftStudioAPI/wiki/How-to-check-if-your-issue-is-already-reported-and-or-solved
This save the time of everyone...
-->

## Expected Behavior
<!--- If you're describing a bug, tell us what should happen -->
<!--- If you're suggesting a change/improvement, tell us how it should work -->

## Current Behavior
<!--- If describing a bug, tell us what happens instead of the expected behavior -->
<!--- If suggesting a change/improvement, explain the difference from current behavior -->

<!--- Erase this part if you aren't using it -->
## Possible Solution
<!--- Not obligatory, but suggest a fix/reason for the bug, -->
<!--- or ideas how to implement the addition or change -->

<!--- Erase this part if you are making a suggestion -->
## Steps to Reproduce <!--- (for bugs) -->
<!--- Provide a link to a live example, or an unambiguous set of steps to -->
<!--- reproduce this bug. Include code to reproduce, if relevant -->
<!--- Use java markdown balise for code or pastebin if it's long (more than 20 lines) -->
1.
2.
3.
4.

## Context
<!--- How has this issue affected you? What were you trying to accomplish? -->
<!--- What you would like to be able to do with the feature you are suggesting? -->
<!--- Providing context helps us come up with a solution that is most useful in the real world -->

<!--- Erase this part if you are making a suggestion -->
## Crash Report
<!--- If you have one, erase this part otherwise -->
<!--- If you have one, you must give it to us. It's REALLY needed -->
<!--- You must use pastebin or a similar site, as the crash report will likely be long -->

<!--- Erase this part if you are making a suggestion -->
## Your Environment
<!--- Include as many relevant details about the environment you experienced the bug in -->
* Version of the api used: <!--- With build number ex: <IP_ADDRESS> -->
* Version of forge used: <!--- With build number ex: <IP_ADDRESS>8 -->
* Link to your project: <!--- If you have one. If it's open source, it's perfect -->

repository: anihacc/CraftStudioAPI

repo_name: anihacc/CraftStudioAPI


text:
# Contributing Guidelines

Please follow common guidelines for our projects [here](https://github.com/packit/contributing).

## Reporting Bugs

- [List of known issues](https://github.com/packit/ogr/issues) and in case you need to create a new issue, you can do so [here](https://github.com/packit/ogr/issues/new).
- Getting a version of `ogr`:<br>
  `rpm -q python3-ogr` or `pip3 freeze | grep ogr`

## Documentation

If you want to update documentation, [README.md](README.md) is the file you're looking for.

## Documentation of the services' APIs

Here are some links to the documentation that could be helpful when contributing:

- GitHub (through `PyGithub`)
  - [PyGithub documentation](https://pygithub.readthedocs.io/)
  - for details also see [official GitHub API docs](https://developer.github.com/v3/)
- GitLab (through `Python-Gitlab`)
  - [Python-Gitlab documentation](https://python-gitlab.readthedocs.io/)
  - for details also see [official GitLab API docs](https://docs.gitlab.com/ee/api/)
- Pagure (through `requests`) - API is dependant on deployed version of Pagure service;
  `ogr` is majorly used on (links lead directly to API docs)
  - [src.fedoraproject.org](https://src.fedoraproject.org/api/0/)
  - [pagure.io](https://pagure.io/api/0/)
  - [git.stg.centos.org](https://git.stg.centos.org/api/0/)

## Testing

Tests are stored in [tests](/tests) directory.

We use [Tox](https://pypi.org/project/tox) with configuration in [tox.ini](tox.ini).

Running tests locally:

```
make prepare-check && make check
```

Or you can run them in a container:

    make build
    make check-in-container

The above builds a local image with all the dependencies using
[ansible-bender](https://github.com/ansible-community/ansible-bender), and
runs the tests in a container created from that image. `TEST_TARGET` can be
set to select a subset of the tests.

As a CI we use [Zuul](https://softwarefactory-project.io/zuul/t/local/builds?project=packit-service/ogr) with a configuration in [.zuul.yaml](.zuul.yaml).
If you want to re-run CI/tests in a pull request, just include `recheck` in a comment.

When running the tests we are using the pregenerated responses that are saved in the ./tests/integration/test_data.
If you need to generate a new file, just run the tests and provide environment variables for the service, e.g. `GITHUB_TOKEN`, `GITLAB_TOKEN`, `PAGURE_TOKEN`. Some API endpoints of Pagure require setting up token for a project: `PAGURE_OGR_TEST_TOKEN`.
The missing file will be automatically generated from the real response. Do not forget to commit the file as well.

If you need to regenerate a response file, just remove it and rerun the tests.
(There are Makefile targets for removing the response files: `remove-response-files`, `remove-response-files-github`, `remove-response-files-gitlab`, `remove-response-files-pagure`.)

In case you (re)generate response files, don't forget to run `pre-commit` that includes cleanup of response files.

## Makefile

### Requirements

- [podman](https://github.com/containers/libpod)
- [ansible-bender](https://pypi.org/project/ansible-bender)
- [buildah](https://github.com/containers/buildah)

### Targets

Here are some important and useful targets of [Makefile](/Makefile):

Use [ansible-bender](https://pypi.org/project/ansible-bender) to build container image from [recipe.yaml](recipe.yaml):

```
make build
```

Install packages needed to run tests:

```
make prepare-check
```

Run tests locally:

```
make check
```

Start shell in a container from the image previously built with `make build`:

```
make shell
```

In a container, do basic checks to verify that ogr can be distributed, installed and imported:

```
make check-pypi-packaging
```

---

Thank you for your interest!


text:
---
description: How to set up Apollo Client for use with Apollo Elements
---

# Usage >> Apollo Client || 10

Before your components can interact with your graph, they need to connect to an `ApolloClient` instance. The easiest and simplest way to do that is with `<apollo-client>`.

## <apollo-client>

Import `@apollo-elements/components/apollo-client` and set it up on your page. If you set the `uri` attribute, `<apollo-client>` will create its own client instance for you. If you use `uri`, you can also set the `validate-variables` boolean attribute to prevent the client from fetching any operation (e.g. query) that does not have all its non-nullable variables set.

```html copy
<apollo-client uri="/graphql" validate-variables>
  <app-root></app-root>
</apollo-client>
```

Nested instances of `<apollo-client>` will control their own decendents

```html copy
<apollo-client uri="/server-a">
  <query-element>
    <!-- This element queries from /server-a -->
  </query-element>

  <apollo-client uri="/server-b">
    <query-element>
      <!-- This element queries from /server-b -->
    </query-element>
  </apollo-client>

</apollo-client>
```

See [`<apollo-client>` guide](./html/) for more info and examples.

## Global Client

If you assign your client to the global variable `window.__APOLLO_CLIENT__`, all the apollo elements in your app will connect to it. This is also the variable that Apollo Client Developer Tools use to connect to the client.

```ts copy
import { client } from './global-apollo-client';
window.__APOLLO_CLIENT__ = client;
```

If you'd prefer to avoid assigning to the `window`, you have more options...

## Controllers' `client` Parameter

Pass the `client` param to controllers to specify the client instance

<code-tabs collection="libraries" default-tab="lit">

  ```html tab html
  <blink>
  The HTML Apollo Elements use the ApolloElement interface. See the previous segments.
  </blink>
  ```

  ```ts tab mixins
  import { ApolloQueryController } from '@apollo-elements/core';
  import { ControllerHostMixin } from '@apollo-elements/mixins';
  import { MyQuery } from './My.query.graphql';
  import { client } from './specific-apollo-client';

  export class ConnectedQuery extends ControllerHostMixin(HTMLElement) {
    query = new ApolloQueryController(this, MyQuery, { client });
  }

  customElements.define('connected-query', ConnectedQuery);
  ```

  ```ts tab lit
  import { ApolloQueryController } from '@apollo-elements/core';
  import { LitElement } from 'lit';
  import { customElement } from 'lit/decorators.js';
  import { MyQuery } from './My.query.graphql';
  import { client } from './specific-apollo-client';

  @customElement('connected-query')
  export class ConnectedQuery extends LitElement {
    query = new ApolloQueryController(this, MyQuery, { client });
  }
  ```

  ```ts tab fast
  import { ApolloQueryBehavior } from '@apollo-elements/fast';
  import { FASTElement, customElement } from '@microsoft/fast-element';
  import { MyQuery } from './My.query.graphql';
  import { client } from './specific-apollo-client';

  @customElement({ name: 'connected-query' })
  export class ConnectedQuery extends FASTElement {
    query = new ApolloQueryBehavior(this, MyQuery, { client });
  }
  ```

  ```ts tab haunted
  import { useQuery } from '@apollo-elements/haunted';
  import { client } from './specific-apollo-client';

  function ConnectedQuery() {
    const { data } = useQuery(gql`query ConnectedQuery { connected }`, { client });
  }
  ```

  ```tsx tab atomico
  import { useQuery } from '@apollo-elements/atomico';
  import { client } from './specific-apollo-client';

  function ConnectedQuery() {
    const { data } = useQuery(gql`query ConnectedQuery { connected }`, { client });
    return <host>...</host>;
  }
  ```

  ```ts tab hybrids
  import { query, define, html } from '@apollo-elements/hybrids';
  import { client as apolloClient } from './specific-apollo-client';

  define('connected-query', {
    query: query(gql`query ConnectedQuery { connected }`, { client }),
  });
  ```

</code-tabs>

## Elements' `ApolloClientMixin`

Import `ApolloClientMixin` from `@apollo-elements/mixins` and apply it to your components' classes to connect them to a specific client:

<code-tabs collection="libraries" default-tab="lit">

  ```html tab html
  <blink>
  There is no equivalent of <code>ApolloClientMixin</code> for HTML,
  so just use the <code><apollo-client></code> element.
  </blink>
  ```

  ```ts tab mixins
  import { ApolloClientMixin, ApolloQueryMixin } from '@apollo-elements/mixins';

  import { client } from './specific-apollo-client';

  interface Data { /* ... */ }
  interface Variables { /* ... */ }

  const Base =
    ApolloClientMixin(client, ApolloQueryMixin(HTMLElement));

  export class ConnectedQuery extends Base<Data, Variables> { /* ... */ }

  customElements.define('connected-query', ConnectedQuery);
  ```

  ```ts tab lit
  import { ApolloClientMixin } from '@apollo-elements/mixins/apollo-client-mixin';
  import { ApolloQuery, customElement } from '@apollo-elements/lit-apollo';
  import { client } from './specific-apollo-client';

  interface Data { /* ... */ }
  interface Variables { /* ... */ }

  const Base =
    ApolloClientMixin(client, ApolloQuery);

  @customElement('connected-query')
  export class ConnectedQuery extends Base<Data, Variables> { /* ... */ }
  ```

  ```ts tab fast
  import { ApolloClientMixin } from '@apollo-elements/mixins/apollo-client-mixin';
  import { ApolloQuery } from '@apollo-elements/fast/bases/apollo-query';
  import { customElement, ViewTemplate } from '@apollo-elements/fast';
  import { client } from './specific-apollo-client';

  const Base =
    ApolloClientMixin(client, ApolloQuery);

  const name = 'connected-query';
  const template: ViewTemplate<ConnectedQuery> = html`...`;

  @customElement({ name, template })
  export class ConnectedQuery extends Base<any> { /* ... */ }
  ```

  ```ts tab haunted
  import { useQuery } from '@apollo-elements/haunted';
  import { client } from './specific-apollo-client';

  // There is no ApolloClientMixin for Haunted, rather
  // the `useQuery`, `useMutation`, and `useSubscription` hooks accept a client option.

  function ConnectedQuery() {
    const { data } = useQuery(gql`query ConnectedQuery { connected }`, { client });
  }
  ```

  ```tsx tab atomico
  import { useQuery } from '@apollo-elements/atomico';
  import { client } from './specific-apollo-client';

  // There is no ApolloClientMixin for Haunted, rather
  // the `useQuery`, `useMutation`, and `useSubscription` hooks accept a client option.

  function ConnectedQuery() {
    const { data } = useQuery(gql`query ConnectedQuery { connected }`, { client });
    return <host>...</host>;
  }
  ```

  ```ts tab hybrids
  import { query, define, html } from '@apollo-elements/hybrids';
  import { client as apolloClient } from './specific-apollo-client';

  // There is no ApolloClientMixin for Hybrids, rather pass the client
  // to the `query`, `mutation`, or `subscription` factory.

  define('connected-query', {
    query: query(gql`query ConnectedQuery { connected }`, { client }),
  });
  ```

</code-tabs>

## Next Steps
- Learn more about [the `<apollo-client>` HTML element](./html/)
- Learn how to write [query components](../queries/)

license: ISC

repository: apollo-elements/apollo-elements

gha_license_id: ISC

repo_name: apollo-elements/apollo-elements