text:
# create-python-app

Like create-react-app, but for python, and dockerized!

# Installing

Run the following commands inside your project directory to add this to your
Python app:

```sh
wget https://raw.githubusercontent.com/mnebuerquo/create-python-app/master/install.sh
sh install.sh <target-directory>
```

The first command downloads the install script, and the second runs the
script, downloads, and configures the rest.

Either place the script in the project where you want to install this, or
run it with the project path as an argument.

Once the install completes, you can run your Python app in a docker
container instead of a virtualenv. It can also be used to build a container
for deploy.

# Usage

Once you have installed the script, you can run the dockerized version of
Python from the local directory instead of the system instance.

## Dev

Run the local python, giving the name of the script as an argument:

```sh
docker-compose run dev app.py
```

This is what you would use for running things in development. Don't forget
to rebuild dev when you add new requirements.

When you next call `docker-compose build dev`, it installs all your new
requirements from `requirements.txt`.

## Test

Create-python-app uses a default requirements.txt containing
[pytest](https://docs.pytest.org/en/latest/), running
[doctest](https://docs.python.org/3/library/doctest.html) with
[pytest-watch](https://github.com/joeyespo/pytest-watch) for
running automated tests while coding. Feel free to replace this with a test
runner of your own.

```sh
docker-compose run pytest
```

*Warning:* The test container only installs dependencies when you build it.
If you add a new dependency to your project and run tests they will fail
until you rebuild the container.

```sh
docker-compose build pytest
```

## Watch

You can run tests whenever a file in your project changes. This is really
useful in a lot of situations. It requires a different container
configuration than the test command described above.

When you run `watch`, it will do a pip install every time it starts. This is
because the container image only contains the test libraries. Any
dependencies added by your project will be installed when the container
starts.

When your code changes, the watcher will re-run the tests without a
installing dependencies. The install step is only when you start the
watcher.

```sh
docker-compose run watch
```

## Lint

Everyone needs to run a linter. This is a great way to improve your code.
I'm using [flake8](http://flake8.pycqa.org/en/latest/index.html) which
combines the powers of a few static code checkers.

```sh
docker-compose run lint
```

## Format

Sometimes you want to try out auto-formatting of code to simplify the cleanup
of old code or so its easy to get new code looking clean before commit.
[Auto formatting python](https://pypi.python.org/pypi/autopep8/1.1.1)
This is now part of this project too, using `docker-compose run format .` in
your project directory. You can pass any path or file as the argument to
format as well.

```sh
docker-compose run format ./src/
docker-compose run format myuglycode.py
```

The format settings should be decent for most projects, and combined with
lint, can help a cleanup effort in a big way.

## Freeze

Edit `requirements.txt` and then `docker-compose run freeze` to pin your
requirements to specific versions and overwrite your requirements.txt file.

This command creates a container, installs all your packages in it, and then
freezes those versions into requirements.txt.

```sh
docker-compose run freeze
```

You can also freeze to a different file by providing a file name on the
command line:

```sh
docker-compose run freeze requirements.freeze
```

*Warning:* `pip install` installs stuff into the container, which is removed
after it runs. So to add a new requirement you can not just run `pip install`!
Edit the requirements.txt instead, and then run `docker-compose build dev`
to install it in the image.

## Safety

[Safety ](https://github.com/pyupio/safety) is a tool for statically
scanning installed packages and checking them against a database of known
package vulnerabilities. In this configuration, it checks the version of every
package pinned in the requirements.txt file.

# Environment Variables

Create a `.env` file in your project directory containing environment variables.
These will be loaded into the docker container when it runs, and your python app
will be able to access them by name.

This is where you put secrets, keys, and passwords, so
do not commit it to git. For deploying to servers, your CI system probably
has a way of setting environment variables when provisioning.

# Deploying to a Server

Coming soon.

# Dependencies

* [Docker](https://www.docker.com/community-edition) is required for running the
  containerized python. Community edition is fine, you don't need enterprise
  support for this.
* [git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git) is
  required for the installer. It clones this repo in a temp directory,
  copies the necessary files to your project, then removes the cloned repo
  from the temp directory.
* [wget](https://stackoverflow.com/a/9491666/5114) is required for the installer
  to download files. This may not be installed on all systems by default,
  but it's easy to find instructions with a google search.

# TODO

* Debugger Support
    - [pudb](https://pypi.python.org/pypi/pudb)
    - [pdb](https://docs.python.org/3.6/library/pdb.html)
    - [web-pdb](https://pypi.python.org/pypi/web-pdb)
* Separate environment files for test and development
* Deploy to production with instructions
	- Gitlab CI
	- Manual deploy instructions
	- Other CI tools?
* Environment variable to choose between python3 (default) and python2.7 in
  the install. This is a low priority for me, because any new projects at
  this point should use python3. I do not plan to support python2 unless
  someone asks me for it.

# Opportunities for Improvement

First, `pip install` is done in the build step. This is so you can just run
the container and have short startup time. The installed packages are not
in a volume, but in the container. This means you can't just `pip install
somepackage`, but you have to add it to `requirements.txt` and then do a
`docker-compose build` to rebuild the container with the new requirement. You
can then do a `docker-compose run dev -m pip freeze > requirements.txt` to
capture the installed packages, but managing the packages is harder with them
inside the container.

I could put the pip install directory in a volume for dev, test, and watch, so
that it persists between containers. That would complicate rebuilds, as well
as having another path in user space for it. The prod build should have
dependencies installed in the container like it is now.

Also, adding network ports or additional volumes is not yet supported. To do
this, you would have to install this into your own project and then edit the
files. Then it can be committed to source control with the rest of your
code.

# Inspiration

* [create-react-app](https://github.com/facebookincubator/create-react-app)
    : a scaffolding for creating a React app without having to figure out
    all the boilerplate
* [whalebrew](https://github.com/bfirsh/whalebrew)
    : Like homebrew, but using docker images to keep everything isolated.
* [Article about docker ENTRYPOINT](http://goinbigdata.com/docker-run-vs-cmd-vs-entrypoint/)
* Team Echo
    : The team I worked with at Kroger Digital. They use Docker for everything.

# Issues and Pull Requests Welcome!

Please let me know how this can be improved for your uses. It's still an
experiment, but I think it's the way of the future.

repository: mnebuerquo/create-python-app

repo_name: mnebuerquo/create-python-app


text:
---
title: Cancelling terms in maths expressions
category: usage
tags: math
permalink: /FAQ-cancellation
---

A technique used when explaining the behaviour of expressions or
equations (often for pedagogical purposes).  The [`cancel`](https://ctan.org/pkg/cancel)
package provides several variants of cancellation marks
(`\ `, `/` and `X`), and
a means of cancelling "to" a particular value.

Documentation of [`cancel`](https://ctan.org/pkg/cancel) is in the package file.

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# FAST archetype : 960gs example

This is a simple project to show how use grid system like [960gs](http://960.gs).

This is a similar archetype to [fast-archetype-yui3](http://smile-sa.github.io/fast-archetype/2.12.1/fast-archetype-yui3) which is based on YUI3 instead of 960gs.

## Prerequisite

We'll assume that you're familiar with [fast-maven-plugin](http://smile-sa.github.io/fast-maven-plugin).

If you don't, check the [fast-archetype-simple](http://smile-sa.github.io/fast-archetype/2.12.1/fast-archetype-simple) at first, it is a very simple example, perfect to start.

## Create a new project

Use the Maven command line :

```
mvn archetype:generate \
	-DarchetypeCatalog=http://smile-sa.github.com/maven-repository/releases/archetype-catalog.xml \
	-DarchetypeGroupId=org.fast.archetype \
	-DarchetypeArtifactId=fast-archetype-960gs \
	-DarchetypeVersion=RELEASE
```

You'll have to set the following properties :

- groupId and artifactId : this is the Maven way to identify your project. *org.acme* for the groupId and *foobar* for the artifactId for example.
- version (you can leave the default setting)
- package (leave default, which should be computed from what you set earlier)

*Build success* should appear if everything went OK.

A new folder have been created, its name is the artifactId.

To get all the Maven dependencies, use this command line :

```
mvn compile
```

Again, *Build success* should appear (you may have to wait the first time to get all dependencies).

## Let's take a look inside

The folder hierarchy is the same as the simple example :

- pom.xml
- src/main/assembly and src/main/filters
- src/main/resources/modules and src/main/resources/pages

The HTML fragmentation into src/main/resources/modules is an example.
The good thing to look at, compared to [fast-archetype-simple](http://smile-sa.github.io/fast-archetype/2.12.1/fast-archetype-simple) is the src/main/resources/modules/layout folder.
We set in this folder some different layout which will be used as nested template to create our page ark and columns.

This good practice helps us to separate the content from the layout, easing module reuse.

In the src/main/resources/pages, we have multiple page defined that show module reuse and how quickly you can create a new page with a different layout.
Also, you'll find a favicon which is something you must not forget (front end good practice, see [YSlow : best practices for speeding up your web site - favicon](http://developer.yahoo.com/performance/rules.html#favicon).

You can see that all static content are into a *v1* folder. It is handy to have version as part of the path to static resource to help cache management (see [YSlow : best practices for speeding up your web site - expires](http://developer.yahoo.com/performance/rules.html#expires)). You don't have to use it that way, you can also use another version systeme like a timestamp (screen.css?_timestamp=123456879).

Content static file are separate from the UI files (the *v1* folder). That way, you can share the UI file between your 2 projects : FAST project and Integrated project. One modification in one of these project will be reflected into the other. It will ease front and back developers to work hand in hand.

The project defined 2 variables into filter.properties :

- static.path.root
- content.path.root

You can use them into your module : ${static.path.root}, ${content.path.root}.

repository: Smile-SA/fast-archetype

repo_name: Smile-SA/fast-archetype


text:
# typescript-library-boilerplate
Boilerplate for typescript library development

## How to use
+ clone the repo (remember to rename the project and edit package.json as appropriate)
+ To build 'npm run build'
+ To run tests 'npm run test'
+ To run code coverage 'npm run coverage'
+ To run tslint 'npm run lint'

license: MIT

gha_language: TypeScript

gha_license_id: MIT


text:
Download and extract from YouTube.

```
python scripts/download/download_hacs.py $TAO_ROOT --split train
```

You can ignore YoutubeDL errors that are printed by this script (e.g., Video not
available). Videos that could not be downloaded will be collected in
`$TAO_ROOT/hacs_missing/missing.txt`. You can request the original HACS videos
by filling out these forms: https://forms.gle/hZD612H5TXDQDozv9

repository: mike-shvets/tao

gha_license_id: NOASSERTION

repo_name: mike-shvets/tao


text:
---
metaTitle: "Android - Publish to Play Store"
description: "Minimal app submission guide"
---

# Publish to Play Store

## Minimal app submission guide

Requirements:

- A developer account
- An apk already built and signed with a non-debug key
- A free app that doesn't have in-app billing
- no Firebase Cloud Messaging or Game Services

Head to [https://play.google.com/apps/publish/](https://play.google.com/apps/publish/)

 1a) Create your developer account if you do not have one

1. Click button `Create new Application`
1. Click submit APK
1. Fill in all required fields in the form, including some assets that will be displayed on the Play Store (see image below)
1. When satisfied hit `Publish app` button

[](https://i.stack.imgur.com/t28JM.png)
[](https://i.stack.imgur.com/S3lhQ.png)

See more about signing in [Configure Signing Settings](http://stackoverflow.com/documentation/android-gradle/5249/configure-signing-settings#t=201608060822323313637)

repository: haifenghuang/generate

repo_name: haifenghuang/generate


text:
# 1. Style and Conventions

## 1.1 Style Guide

Composer generally follows Google's
[Python Style Guide](https://google.github.io/styleguide/pyguide.html) for how to format and structure code.

## 1.2. Pre-Commit Hooks

Composer uses [Pre Commit](https://pre-commit.com/) to enforce style checks. To configure, run
```
pip install '.[dev]'  # if not already installed
pre-commit install
```

The pre-commit hooks will now be run before each commit. You can also run the hooks manually via:

```
pre-commit run  # run all hooks on changed files
pre-commit run --all-files  # or, run all hooks on all files
```

## 1.3. Code Formatting

Composer uses the [yapf](https://github.com/google/yapf) formatter for general formatting
[isort](https://github.com/PyCQA/isort) to sort imports. These checks run through pre-commit
(see section 2.2). These checks can also be run manually via:

```
pre-commit run yapf --all-files  # for yapf
pre-commit run isort --all-files  # for isort
```

The configuration is stored in [pyproject.toml](pyproject.toml).

## 1.4. Code Structure

As a general rule of thumb,

-   Don't: Default to using inheritance for code reuse

    Do: prefer [composition over inheritance](https://en.wikipedia.org/wiki/Composition_over_inheritance)
-   Don't: strive to implement all logic using classes

    Do: strive to implement logic as pure functions when possible, and classes when there is good reason
-   Don't: Have a function accept falsy values that would then result in a no-op.

    Example of the anti-pattern:

    ```python
    from typing import Optional

    def configure_deepspeed(deepspeed_config: Optional[dict]):
        if deepspeed_config is None:
            # Don't do this check in the callee, which results in a no-op
            return
        ...
    ```

    Do: Require the caller, instead of the callee, check for and handle falsy values. It's ok to accept falsy values
    for individual arguments of a caller function, so long as the entire function would not be a no-op.

    Example:
    ```python
    from typing import Optional

    def configure_deepspeed(deepspeed_config: dict):
        ...

    def trainer(deepspeed_config: Optional[dict]):
        if deepspeed_config is not None:
            # Do this check in the caller function
            configure_deepspeed(deepspeed_config)
        ...
    ```

# 2. Type Annotations and Typechecking

Composer aims to annotate all functions with type annotations (introduced in
[PEP 526](https://www.python.org/dev/peps/pep-0526/)). Type annotations help statically catch `TypeError` and
`AttributeError` bugs, in addition to other benefits, as outlined in the PEP.

For documentation on typing annotations, see:
* [PEP 483](https://peps.python.org/pep-0483/) for a simplified introducation
* [PEP 484](https://peps.python.org/pep-0484/) for the full specification
* [Python docs for `typing`](https://docs.python.org/3/library/typing.html) for the API reference

Composer uses [pyright](https://github.com/microsoft/pyright)
to validate type annotations. PyRight is automatically run as part of the pre-commit hooks, but you can also
run PyRight specifically via:

```
pre-commit run pyright --all-files
```

The pyright configuration is stored in [pyproject.toml](pyproject.toml).

## 2.1 Debugging

Here are some suggestions to deal with pyright errors:

1. Suppose a variable could be one of multiple types, like the following:

    ```python
    from typing import Union

    def foo(x: Union[int, None]):
        return x + 5  # type error -- None + 5 is not allowed!
    ```

    PyRight will complain since `None + 5` is not a valid operation.
    Instead, add a check to ensure that `x is not None`:

    ```python
    from typing import Union

    def foo(x: Union[int, None]):
        if x is None:
            raise TypeError("x must be an integer, not None!")
        return x + 5  # valid
    ```

    Assert statements also work. However, assert statements should not be used for data validation
    (see the assert statement section below).
    ```python
    from typing import Union

    def foo(x: Union[int, None]):
        assert x is not None, "x should never be None"
        return x + 5  # valid
    ```

1. For variables where it is impossible for pyright to infer the correct type, use
[cast](https://docs.python.org/3/library/typing.html#typing.cast).
1. As a last resort, add a `# type: ignore` comment to the line where pyright emits an error.
Immediately following this statement, paste in the error emitted by pyright,
so other contributors will know why this error was silenced.

# 3. Public APIs
A public API, generally speaking, can be invoked by a user without a leading underscore in any portion of the path.
The following are examples of public APIs:

* Standalone functions in public modules (e.g. `composer.utils.dist.get_world_size`)
* Classes in public modules (e.g. `composer.trainer.trainer.Trainer`)
* Public methods in public classes (e.g. `composer.trainer.trainer.Trainer.fit`)
* Public modules (e.g. `composer.trainer.trainer`)

The following rules apply to public APIs:
1. All public APIs must have a docstring (see the Documentation section below)
1. All parameters must have type annotations.
1. To minimize user imports, parameters should should use native PyTorch or Python types whenever possible.

    It is acceptable to use a union of types, so long as one of the options is a primitive. For example, in the
    constructor for `composer.trainer.trainer.Trainer`, the `device` parameter is annotated like the following:

    ```python
    from typing import Optional, Union

    from composer.devices import Device

    class Trainer:
        def __init__(
            self,
            device: Union[str, Device],
        ):
            if isinstance(device, str):
                device = Device(device)
            ...
    ```

    This signature allows a user to pass a string for a device,
    rather than having to import our custom device class.

    Parameters that are for power users (such as `load_object_store`) in the Trainer are exempt from this rule.
    These parameters can require custom imports.

1. Parameters that could take a sequence of elements should also allow `None` or a singleton.
    This simplifies the user API by not having to construct a list (or tuple) to hold a single element
    (or no element). For example, use `Optional[Union[torch.Tensor, Sequence[torch.Tensor]]`.

    The `composer.utils.ensure_tuple` helper method can convert a singleton, list, or tuple into a tuple.
    For example

    ```python
    from torch import Tensor
    from typing import Optional, Sequence, Tuple, Union
    from composer.utils import ensure_tuple

    def foo(x: Optional[Union[Tensor, Sequence[Tensor]]]) -> Tuple[Tensor, ...]:
        return ensure_tuple(x)  # ensures that the result is always a (potentially empty) tuple of tensors
    ```

# 4. Use of `assert`

`assert` should be used only in test cases and for verifying invariants (likely required for type checking),
not for data validation. As asserts can be disabled in python by using the `-O` flag
(e.g. `python -O path/to/script.py`), they are not guaranteed to run. For data validation, instead use a style like
the following:

<!--pytest.mark.xfail-->
<!--
```python
parameter = None
```
-->
<!--pytest-codeblocks:cont-->
```python
if parameter is None:
    raise ValueError("parameter must be specified and cannot be None")
```

# 5. Imports and `__init__.py`

All imports in composer should be absolute -- that is, they do not begin with a period.

## 5.1 External Dependencies
1.  All external dependencies must be specified in both [setup.py](setup.py) for pip and [meta.yaml](meta.yaml)
    for Anaconda.

1.  If a dependency is not core to Composer (e.g. it is for a model, dataset, algorithm, or some callbacks):
    1.  It must be specified in a entry of the `extra_deps` dictionary of [setup.py](setup.py).
        This dictionary groups dependencies that can be conditionally installed. An entry named `foo`
        can be installed with `pip install 'mosaicml[foo]'`. For example, running `pip install 'mosaicml[unet]'`
        will install everything in `install_requires`, along with `monai` and `scikit-learn`.
    1.  It must also be specified in the `run_constrained` and the `test.requires` section.
    1.  The import must be conditionally imported in the code. For example:

        <!--pytest-codeblocks:importorskip(monai)-->
        <!--pytest-codeblocks:importorskip(scikit-learn)-->
        ```python
        from composer.utils import MissingConditionalImportError

        def unet():
            try:
                import monai
            except ImportError as e:
                raise MissingConditionalImportError(extra_deps_group="unet",
                                                    conda_package="monai",
                                                    conda_channel="conda-forge",) from e
        ```

        This style allows users to perform minimal install of Composer without triggering `ImportError`s if
        an optional dependency is missing.

        If the corresponding package is not published on Anaconda, then set the ``conda_package`` to the pip package
        name, and set ``conda_channel`` to ``None``. For example, with DeepSpeed:

        <!--pytest-codeblocks:importorskip(deepspeed)-->
        ```python
        from composer.utils import MissingConditionalImportError

        try:
            import deepspeed
        except ImportError as e:
            raise MissingConditionalImportError(extra_deps_group="deepspeed",
                                                conda_package="deepspeed>=0.5.5",
                                                conda_channel=None) from e
        ```

    1.  If the dependency is core to Composer, add the dependency to the `install_requires` section of
        [setup.py](./setup.py) and the `requirements.run` section of [meta.yaml](./meta.yaml).

## 5.2 Use of `__all__`

All public modules must define `__all__` to be the list of members that should be re-exported.
The variable is necessary to 1) limit what `from XXX import *` imports, and 2) ensure that the documentation only
includes exported members, not unrelated re-imports.

For example, from [composer/callbacks/memory_monitor.py](composer/callbacks/memory_monitor.py)

```python
"""Log memory usage during training."""
import logging
from typing import Dict, Union

import torch.cuda

from composer.core import State
from composer.loggers import Logger
from composer.core.callback import Callback

log = logging.getLogger(__name__)

__all__ = ["MemoryMonitor"]  # export only the MemoryMonitor, not other imports like `Logger`, `State`, or `Callback`

class MemoryMonitor(Callback):
    ...
```

## 5.3 `__init__.py`

All public classes and functions should be added to the module's `__init__.py`.

<!--pytest.mark.skip-->
```python
from composer.path.to.module.file import MyClass as MyClass
from composer.path.to.module.file import my_func as my_func
```

If a file only contains public functions, then the following is also acceptable:

<!--pytest.mark.skip-->
```python
from composer.path.to.module import my_file as my_file
```

# 6. Documentation

## 6.1 Docstrings

Composer uses [Google Style Docstrings](https://sphinxcontrib-napoleon.readthedocs.io/en/latest/example_google.html).
All public APIs require documentation.

### 6.1.1 What to include in Docstrings?

Docstrings, at a minimum, should include a summary of what the function or class does, along with the arguments it takes. See [below](#612-formatting-docstrings) for how to format docstrings. The [Google Style Guide](https://google.github.io/styleguide/pyguide.html) also includes some guidelines on how to write docstrings.

### 6.1.2 Formatting Docstrings

The following guidelines apply to documentation.
1.  Each function that needs a docstring must have its input arguments, return statement (if not None), and any custom
    exceptions annotated.
1.  The arguments for the `__init__` signature of classes should be documented under the class-level docstring. There
    should not be any `__init__`-level docstring.
1.  Each argument annotation should include the type. If the argument has a default value, the type annotation should
    specify "optional", and the docstring should say the default value. Some examples:

    ```python
    from typing import Optional, Tuple, Union

    def foo(bar: int):
        """Foo.

        Args:
            bar (int): Required bar.
        """
        ...

    def foo2(bar: int = 42):
        """Foo2.

        Args:
            bar (int, optional): The first Argument. Default: ``42``.
        """
        ...

    def foo3(bar: Optional[int] = None):
        """Foo3.

        Args:
            bar (int, optional): The first Argument. Default: ``None``.
        """
        ...

    def foo4(bar: Union[int, str] = 42):
        """Foo4.

        Args:
            bar (int | str, optional): The first Argument. Default: ``42``.
        """
        ...

    def foo5(bar: int) -> int:
        """Foo5.

        Args:
            bar (int): Required bar.

        Returns:
            int: Description of return statement.
        """
        ...

    def foo6(bar: int) -> Tuple[int, str]:
        """Foo6.

        Args:
            bar (int): Required bar.

        Returns:
            a (int): Returned value.
            b (str): Returned value.
        """
        ...
    ```

### 6.1.3 Building and Viewing Docs Locally

Assuming you already have a development install of Composer (see these [instructions](CONTRIBUTING.md#prerequisites)), here’s how to build and previous the docs locally.

** ⚠ Warning:** Jenkins treats all sphinx warnings as errors, so they must be addressed before a PR can be merged. Building docs locally can help debug any warnings showing up on Jenkins!

In one terminal, run:

<!--pytest.mark.skip-->
```bash
source path/to/composer_venv/bin/activate  # activate your composer virtual env
cd composer/docs  # cd to the docs folder insde your composer clone
make clean
make html
```

In a second terminal, run:

<!--pytest.mark.skip-->
```bash
cd composer/docs
python3 -m http.server --directory _build/html/
```

Then, navigate to [http://localhost:8000](http://localhost:8000) in your browser.

## 6.2 Doctests

Most docstrings should also include a `.. doctest` or `.. testcode` example to clearly illustrate how one would interact with the class or function. As part of the CI/CD process, all `.. doctest` blocks are executed to ensure the example in the documentation actually works.

### 6.2.1 Writing Doctests

See the [Sphinx Doctest Extension](https://www.sphinx-doc.org/en/master/usage/extensions/doctest.html) for all of the available directives. Do not use `.. code-block::` for Python examples, as they are untested.

Any test fixtures for doctests should go in [docs/source/doctest_fixtures.py](docs/source/doctest_fixtures.py) or in a `.. testsetup::` block.

For example:
```python
import torch
from typing import Optional

def my_function(x: Optional[torch.Tensor]) -> torch.Tensor:
    """blah function

    Args:
        input (torch.Tensor): Your guess.

    Returns:
        torch.Tensor: How good your input is.

    Raises:
        ValueError: If your input is negative.

    Example:
        .. testsetup::

            # optional setup section, not shown in docs
            import torch
            x = torch.randn(42)

        .. testcode::

            # shown in docs; runs after testsetup
            my_function(x)
    """
    ...
```

All doctests load the [docs/source/doctest_fixtures.py](docs/source/doctest_fixtures.py) file *before* tests run. If there are any variables that would be helpful have defined for all tests, feel free to add them into this file. However, if a variable is more specific to an individual doctest, then it would be best to include it in a `.. testsetup::` block, as not to pollute the global fixture namespace. (Unlike pytest fixtures, all doctest fixtures are given to every doctest; they cannot be specifically requested)

### 6.2.2 Running Doctests Locally

Assuming you already have a development install of Composer (see these [instructions](CONTRIBUTING.md#prerequisites)), here’s how to run the doctests.

<!--pytest.mark.skip-->
```bash
source path/to/composer_venv/bin/activate  # activate your composer virtual env
cd composer/docs  # cd to the docs folder insde your composer clone
make clean
make html  # the html build must be completed first to ensure all doctests are identified
make doctest 2>/dev/null # For more verbosity, do not direct stderr to /dev/null
```

repository: sarvex/composer

branch_name: refs/heads/dev

gha_language: Python

repo_name: sarvex/composer


text:
scalaz-scalatest
================

[![Build Status](https://travis-ci.org/typelevel/scalaz-scalatest.svg?branch=master)](https://travis-ci.org/typelevel/scalaz-scalatest)

Scalatest bindings for scalaz.  Partially inspired by scalaz-specs2.

Apache 2.0 licensed.

**Current Version:** 0.3.0

*Some stuff is still in flight as we work with Scalatest to simplify some syntax. Changes will be minor but may effect matcher syntax for the next few releases.*

Matchers & Helpers are presently offered for testing of the following scalaz concepts:
* Disjunction – aka `\/` ( with extra helpers similar to Scalatest `OptionValues` )
* `Validation` ( with extra helpers similar to Scalatest `OptionValues` )

## Setup

We currently crossbuild for Scala 2.10 & 2.11. Test builds run against OpenJDK 6 & 7, and OracleJDK 7 & 8.

(NOTE: *As of November 24, 2014, The project should be synced to Maven central*)

To include this in your project, add the dependency (substituting version # as necessary):

```sbt
libraryDependencies += "org.typelevel" %% "scalaz-scalatest" % "0.3.0" % "test"
```
## Usage

There are two ways to use the provided matchers.

* Mix-In

```scala
class MySillyWalkSpec extends FlatSpec with Matchers with DisjunctionMatchers {
  // ...
}
```
This makes the matchers in `DisjunctionMatchers` available inside the scope of your test.

You can also import explicitly from a provided object, instead.

```scala
import org.typelevel.scalatest.DisjunctionMatchers

class MySillyWalkSpec extends FlatSpec with Matchers {
  import DisjunctionMatchers._
  // ...
}

```

Also brings the matchers into scope.

And now, the matchers themselves.

### `DisjunctionMatchers`

Disjunction matchers are provided for testing of `\/` instances. In addition, see below for information on the special `DisjunctionValues` helpers.

#### `DisjunctionValues`

If you would like to assume the right-bias of `\/` in your tests, we provide a "Values" helper similar to Scalatest's own `OptionValues`. This lets you invoke `value` and then treat it as if it is `\/-` (right). If it *isn't* right, the test will fail.

This can be mixed in or explicitly imported via Object helper.
```scala
import org.typelevel.scalatest.DisjunctionValues
import DisjunctionValues._

val thisRecord = "I will not buy this record, it is scratched."
val thisTobacconist = "Ah! I will not buy this tobacconist's, it is scratched."
val hovercraft = "Yes, cigarettes. My hovercraft is full of eels."

repository: monkeygroover/scalaz-scalatest

gha_language: Scala

repo_name: monkeygroover/scalaz-scalatest


text:
## FileCopy Remote - Moves a file from a source location to a destination location supporting impersonation with credentials provided in the the activity

## DLL's to reference

SimpleImpersonation.dll

## Fields to be set in the activity.

**Source Path:** The path of the source file (when accessing a remote machine or a shared location use UNC format).

**Destination Path:** The path of the destination file (when accessing a remote machine or a shared location use UNC format).

**Username:** A username (Domain\Username) that has access to both locations ( source and destination ), can be left empty if not required

**Password:** The password of the account listed in the Username field.

**Overwrite:** Specify whether to overwrite the destination file or not.

repository: Ayehu/custom-activities

gha_language: C#

repo_name: Ayehu/custom-activities


text:
Additional spectrum classification dataset operations.

For core dataset operations, see [here](datasets.md).

## URL

Uses `/v1/spectra/datasets/` instead of `/v1/datasets/`,
also for the core operations.

## Actions

### Get Categories

Gets the categories for each spectrum in a dataset.

#### Method

`GET`

#### URL

`/v1/spectra/datasets/{PK}/categories`

#### Parameters

  * `PK`: int (primary key of the dataset)

#### Permissions

  * [user is a member of the team that owns the dataset](permissions.md#ismember), or
  * [user is admin](permissions.md#isadminuser)

#### Response

  A JSON object from filename to an array of categories for the file.

### Get Categories For File

Gets the categories for a spectrum in a dataset.

#### Method

`GET`

#### URL

`/v1/spectra/datasets/{PK}/categories/{FILENAME}`

#### Parameters

  * `PK`: int (primary key of the dataset)
  * `FILENAME`: str (name of the new file)

#### Permissions

  * [user is a member of the team that owns the dataset](permissions.md#ismember), or
  * [user is admin](permissions.md#isadminuser)

#### Response

  A JSON array of categories for the file.

### Modify Categories

Modifies the categories for spectra in a dataset.

#### Method

`PATCH`

#### URL

`/v1/spectra/datasets/{PK}/categories`

#### Parameters

  * `PK`: int (primary key of the dataset)

#### Body

  * method: str (either "add" or "remove")
  * images: array of str (the filenames of spectra to modify categories for)
  * categories: array of str (the categories to either add or remove from the spectra)

#### Permissions

  * [user is a member of the team that owns the dataset with write permission](permissions.md#memberhaswritepermission), or
  * [user is admin](permissions.md#isadminuser), or
  * both:
    * [user is a member of the team that owns the dataset with execute permission](permissions.md#memberhasexecutepermission), and
    * [user is a node](permissions.md#isnode)

#### Response

  A JSON object from filename to the categories added to/removed from the file.

### Set Categories

Sets the categories for spectra in a dataset.

#### Method

`POST`

#### URL

`/v1/spectra/datasets/{PK}/categories`

#### Parameters

  * `PK`: int (primary key of the dataset)

#### Body

  A JSON object from filename to an array of categories for the file.

#### Permissions

  * [user is a member of the team that owns the dataset with write permission](permissions.md#memberhaswritepermission), or
  * [user is admin](permissions.md#isadminuser), or
  * both:
    * [user is a member of the team that owns the dataset with execute permission](permissions.md#memberhasexecutepermission), and
    * [user is a node](permissions.md#isnode)

#### Response

  A JSON object from filename to an array of categories for the file.

repository: waikato-ufdl/ufdl-api

repo_name: waikato-ufdl/ufdl-api


text:
## 0.2.2 (WIP)

## 0.2.1 (2016-10-18)

* Added spinners, which can be rendered in the statusbar
* Added `Janeway#redraw`, which forces a re-render
* Added indicators

## 0.2.0 (2016-10-14)

* Added menu bar
* Added 'Copy' button to copy current selection to the clipboard
* The currently selected object/string will be stored under the $0 global
* `Janeway#setTitle(str)` will now set the title of the terminal tab
* Remove 'Line 0' when Janeway starts
* If a new line contains the same data as the previous one, it is not
  printed to screen, but a counter is added to that previous line.
* The CLI now uses a modified Textarea widget: arrow keys, delete, home, end now all work as they should
* Added a statusbar under the CLI, which can be set using `Janeway#setStatus`, it should only be given regular text, though it does support blessed tags.
* Move classes to the Develry.Janeway namespace
* The Janeway instance can now be accessed at the `__Janeway` global
* Only +/- 1000 lines will be stored, when going over that the top lines will be removed
* `eval` is no longer used to evaluate CLI code, now `vm#runInNewContext` is used
* The new CLI evaluation now has access to `require`
* Because of ditching `eval`, declaring variables (or asigning without `var`) will no longer create a global. In order to create on, you'll have to do something like `global.myglobal = 'globalvalue'`
* Added `getPropertyNames` to recursively look through an object's prototype chain to fill the autocomplete popup
* Command evaluation will first wrap the command in parentheses, if it fails it tries it without them.
* The `janeway` command will set the title on boot
* Autocomplete will now also select current item when typing '(', it already does this for '.', a tab and an enter

## 0.1.6 (2016-06-02)

* Add brackets when opening objects
* Also split strings on \r\n or \r newlines
* Show `__proto__` property when inspecting objects
* Add timestamp to loglines
* Remove '.js' from filenames
* Added `uncaughtException` listener to print errors before crashing
* Changed scrolledManually and scrollDown property to underscored name
* Let Janeway handle application crashes better

## 0.1.5 (2016-01-24)

* Add autocomplete (basic for now)
* Add CLI history
* Allow Janeway to be run globally
* Add date object to line info

## 0.1.4 (2016-01-20)

* Improve multiline string support
* Upgrade `blessed` dependency to 0.1.81
* Throttle the `render` method to not overload the process
* Automatically scroll down when new line is added
* Clicking on functions will now read out properties
* Pressing pageup/pagedown will scroll up or down
* Fix click/scroll index issues

## 0.1.3 (2015-03-07)

* Stringify Objects using util.inspect, to prevent toJSON interference
* Caller info is added (where the output came from in the script)
* Strings with newlines will be printed out along multiple lines when selected
* Updated blessed dependency

## 0.1.2 (2015-01-26)

* Fixed bug where lines were kept in memory and causes screen glitches
* Fixed global scope command problem (removed vm in favour of regular eval)
* Added Janeway.debug method, which outputs to a logfile
* Upgraded "blessed" dependency to 0.0.38
* More minor bugfixes

## 0.1.1 (2014-09-15)

* require('janeway') will now return an instance of the Janeway class
* Janeway now takes command of `stdout`, `stderr` and all the `console` methods
* Janeway is now also an event emitter (Using Protoblast's Informer class)
* Newlines are now replaced with a Unicode return symbol
* Added new commands to the CLI:
  - 'exit' will exit Janeway and the running app (as will Escape or Control+C)
  - 'cls' will clear the screen

## 0.1.0 (2014-09-14)

* Initial Github commit and npm release!

repository: MrRacoon/janeway

gha_language: JavaScript

repo_name: MrRacoon/janeway


text:
---
date: 2018-10-25T20:01:43-07:00
title: "Link"
weight: 7
aliases: [/core-concepts/tracing/span/link]
---

#### Link

A link describes a cross-relationship between spans in either the same or different trace.
For example if a batch operation were performed, comprising of different traces or different
processes, a link from one span to another can help correlate related spans.

It consists of fields:

* TraceID
* SpanID
* Type which can either be `CHILD`, `PARENT` or `UNKNOWN`
* [Attributes](#attributes)

It is especially useful for linking spans that perhaps might cross trust boundaries. For example, if your API
client libraries in your customers' applications and the wild make calls to your cloud, you could choose to
create a span when the request hits your cloud's frontend server but not show it to the user. By linking
the user's span

repository: ACEmilG/opencensus-website

repo_name: ACEmilG/opencensus-website


text:
## FIRST and FRC

This section will discuss what FRC is and how it fits into FIRST's set of programs and goals.

### FIRST

FIRST (For the Inspiration and Recognition of Science and Technology) is a global nonprofit organization headquartered in Manchester, NH. According to its website:

> FIRST inspires young people to be science and technology leaders and innovators by engaging them in exciting mentor-based programs that build science, engineering, and technology skills, that inspire innovation, and that foster well-rounded life capabilities including self-confidence, communication, and leadership.

In summary, FIRST promotes STEM education by organizing robotics programs for students of all ages. Their three programs are FIRST LEGO League, FIRST Tech Challenge, and FIRST Robotics Competition.

For more information about FIRST, go to [firstinspires.org](https://www.firstinspires.org).

### FIRST LEGO League

FIRST LEGO League (FLL) is a program for kids from preschool to eighth grade. It is subdivided into three programs: FLL Discover (Pre-K - Grade 1), FLL Explore (Grades 2 - 4), and FLL Challenge (Grades 4 - 8). The first two divisions are simply research and exploration challenges for young students. FLL Challenge is a competition where teams work with LEGO MINDSTORMS kits and block programming to complete various tasks on a tabletop.

### FIRST Tech Challenge

FIRST Tech Challenge (FTC) is a robotics competition for students from grades 7 to 12. Teams consist of up to 15 students. Originally, the program was designed to offer a cheaper alternative to FRC for schools that wanted a robotics program but couldn't afford FRC. However, it has since established itself as a strong and independent program. FTC students design robots to fit in an 18" cube and program their robots with block programming or Java. Then, they compete against other teams in a 2v2 format. Teams also work to raise money, do outreach events at local schools, and create an engineering notebook.

### FIRST Robotics Competition

FIRST Robotics Competition (FRC) is FIRST's flagship robotics program. It is for students from grades 9 to 12, and adults (e.g. teachers, engineers, etc.) work with the students. Team sizes vary—in fact, some teams have nearly 100 students—but most teams have around 30 students. Each team designs and builds a 125 lb robot and programs in Java, C++, or LabVIEW. Then, teams compete in a 3v3 format. FIRST's website reads:

> We call FIRST Robotics Competition the ultimate Sport for the Mind. High-school student participants call it "the hardest fun you’ll ever have." It's as close to real-world engineering as a student can get.

In addition to engineering, FRC teams work year-round to raise funds, do outreach events, and develop a team brand.

### Which program is right for me?

Since FLL doesn't have any overlap with FRC by age range, we will focus on the differences between FRC and FTC. In general, FRC is like FTC but bigger: FRC robots are heavier and more powerful, FRC teams and events are larger, FRC budgets are more expensive, etc. In our school district, there is one FTC team at each high school and one FRC team shared by all the high schools.

Below is a table comparing the FTC and FRC programs in our school district.

|Criterion|FTC|FRC|
|:--------:|:-:|:-:|
|Team(s)|

[Raw Bacon (8743)](http://rawbacon8743.weebly.com/)

Lightning Bots (15050)

[Trobotix (8696)](https://sites.google.com/view/trobotix)

|[Children of the Corn (167)](https://www.iowacityrobotics.org)|
|Students Per Team|Up to 15|30+|
|Meeting Location|At school|Kirkwood Regional Center|
|Competition Season|September - February|January - April|
|Robot Dimensions|18" x 18" x 18"|30" x 30" x 84"|
|Robot Weight|30 lbs (roughly)|125 lbs|
|Programming Language|Java|Java|
|Field Dimensions|12' x 12'|27' x 54'|
|Event Locations|School gyms and hotels|Arenas and convention centers|
|Team Budget|$4,000|$40,000|
|Robot Picture|||

license: ISC

branch_name: refs/heads/devel

gha_license_id: ISC


text:
### Description

eGovernment platform “Rozumne Misto” is an all-Ukrainian online platform of e-dem, e-gov and e-services for citizens, local governments, business and NGOs.
Effective tool for development partnership between state governance, citizens and business.

### Document reference for modules used

##Design
https://almsaeedstudio.com/themes/AdminLTE/index2.html

### Installation
```
1. Import from 'for_deploy' folder SQL-dump to your MySQL base (called 'weunion' by default)
2. If you're using the WindowsOS install Mysql connector and XMLlib firstly: pip install mysqlclient-1.3.7-cp34-none-win_amd64.whl ,
lxml-3.6.0-cp34-cp34m-win_amd64.whl
3. Than install all requirements: pip install -r requirements.txt
4. Rename mysqldb.conf.sample to mysqldb.conf. Change if you want db-name/login and pass.
That's it! If you have any question feel free to contact with us through email -<EMAIL_ADDRESS>

##PRODUCTION SERVER
```
Then run the project
```
#uwsgi --ini /etc/uwsgi/weunion-pub.ini
```
Stop project
```
#uwsgi --stop /tmp/master-weunion.pid
```
Log file
```
/var/log/uwsgi/weunion.log
```
Or for local instance
```
python manage.py runserver
```
sudo nginx restart


text:
---
id: tracing-serverless-application
title: Tracing a Serverless Application
sidebar_label: Serverless Application
slug: /tracing/serverless-application
---

Recap.dev provides two levels of tracing: **basic tracing** and **function-level** tracing

**Basic tracing** collects request, response and error information, logs and provides a timeline of external resource access (databases, http endpoints, external services) of your unit (basically, endpoint or handler).

**Function-level** tracing also adds timings of the individual function calls to the timeline.

## Setting up a Basic Tracing

Recap.dev currently supports tracing of Serverless Framework out of the box.
It's also easy to setup tracing for [applications not using Serverless Framework](/docs/tracing/serverless-application#applications-not-using-serverless-framework).

### Serverless Framework

To use recap.dev with the Serverless Framework all you need to do is to add recap.dev
serverless plugin and configure it.

#### 1. Install recap.dev serverless plugin

```bash
yarn add --dev @recap.dev/serverless-plugin
```

or

```bash
npm i --save-dev @recap.dev/serverless-plugin
```

#### 2. Install recap.dev client library

```bash
yarn add @recap.dev/client
```

or

```bash
npm i --save @recap.dev/client
```

#### 3. Add recap.dev plugin to your serverless.yml

Please note that recap.dev plugin should be the first plugin in the list.

```yml
plugins:
  -<EMAIL_ADDRESS>```

#### 4. Add `RECAP_DEV_SYNC_ENDPOINT` environment variable

It should point to your recap.dev server installation.

```yml
provider:
  environment:
    RECAP_DEV_SYNC_ENDPOINT: http://recap-dev.company.com:8080/traces
```

After doing this and redeploying you should start getting tracing data with basic details.

Check out an example project [here](https://github.com/infinite-cat/recap.dev-example-serverless-project).

### Applications Not Using Serverless Framework

Almost any serverless application can be easily traced with recap.dev even when not using Serverless Framework.

#### 1. Install recap.dev client library

```bash
yarn add @recap.dev/client
```

or

```bash
npm i --save @recap.dev/client
```

#### 2. Wrap Your Handler Function with Recap.Dev

Use `wrapLambdaHandler` exported from the<EMAIL_ADDRESS>package like this:

```js
import { wrapLambdaHandler } from<EMAIL_ADDRESS>
export const handler = wrapLambdaHandler(async () => {
  const response = await fetch('https://cat-fact.herokuapp.com/facts')
  return response.json()
})
```

#### 3. Add `RECAP_DEV_SYNC_ENDPOINT` environment variable

It should point to your recap.dev server installation.

```yml
provider:
  environment:
    RECAP_DEV_SYNC_ENDPOINT: http://recap-dev.company.com:8080/traces
```

## Setting up a Function-level Tracing

Click [here](/docs/tracing/function-level-tracing) to learn how to set up the function-level tracing for your application.


text:
The XMP Media Production SDK needs XMP Toolkit Software Development Kit (SDK) by Adobe.

 This release uses Version 5.6.0 of XMPCore.

 To get XMP Toolkit SDK :

 1. Obtain a copy of the XMP Toolkit SDK source code (not the compiled dll) from the XMP Devnet page.

 2. Build the libraries of XMP for the platform you need.

 3. Place the public folder of XMP SDK containing sub-folders of include and libraries directly in .../imports/XMPToolkit

repository: connectthefuture/UMC

repo_name: connectthefuture/UMC


text:
# Linkify-it TLDs

Comprehensive list of TLDs, sourced from ICANN, for [linkify-it](https://github.com/markdown-it/linkify-it).

This is basically the same as [node-tls](https://github.com/stephenmathieson/node-tlds), but TLDs that are shorter than 3 characters are not listed as [linkify-it](https://github.com/markdown-it/linkify-it) uses a [regex](https://github.com/markdown-it/linkify-it/blob/6f3c94916a5e1bd9a246cb7166ec3ee6adbde6bb/index.js#L116-L117) for matching them all. This improves performance slightly.

## Install

```sh
npm install --save linkify-it-tlds
```

## Usage

```ts
import linkify from 'linkify-it';
import tlds from 'linkify-it-tlds';

const instance = linkify ();

instance.tlds ( tlds, true ); // It's important to pass "true", as that ensures the default TLDs will be still supported, as this package doesn't provide them
```

## License

MIT © Fabio Spampinato

repository: fabiospampinato/linkify-it-tlds

repo_name: fabiospampinato/linkify-it-tlds


text:
# BentoML 🤝 Flask Demo Project

0. Install dependencies:

```bash
pip install -r ./requirements.txt
```

1. Train an Iris classifier model, similiar to the quickstart guide:

```bash
python ./train.py
```

2. Run the service:

```bash
bentoml serve service.py:svc
```

3. Send test request

Test the `/predict_bentoml` endpoint:

```bash
$ curl -X POST -H "content-type: application/json" --data "[[5.9, 3, 5.1, 1.8]]" http://<IP_ADDRESS>:3000/predict_bentoml

[2]%
```

Now for Flask integration endpoints:

Test the custom `/metadata` endpoint:

```bash
$ curl http://<IP_ADDRESS>:3000/metadata

{"name":"iris_clf","version":"3vl5n7qkcwqe5uqj"}
```

Test the custom `/predict_flask` endpoint:

```bash
$ curl -X POST -H "content-type: application/json" --data "[[5.9, 3, 5.1, 1.8]]" http://<IP_ADDRESS>:3000/predict_flask

[2]
```

4. Build Bento

```
bentoml build
```

5. Build docker image

```
bentoml containerize iris_flask_demo:latest
```

repository: bentoml/BentoML

branch_name: refs/heads/main

repo_name: bentoml/BentoML


text:
---
title:  Genuine Service
date:  27/09/2019
---

**Exploration**: Hebrews 10

**Conclude**

There is a well-known saying that goes, “The definition of insanity is doing the same thing over and over and expecting different results.” Christ in His Word has time and time again outlined His perfect will for the church. He not only teaches us but came to this earth to give us a living example and make a way for us to walk in the “new and living way” (Heb. 10:20). Christ calls us to reject the easy, mechanical, and cold way we’ve been purporting service to be. He’s made a way for us to reach out in true service to those who need it the most. Hebrews 10 is a love letter; it’s a call for God’s people to be who He’s called them to be. To be authentic. To be real. To be a community of servants in a world where to be served seems most important. Let us support each other and encourage each other, and by God’s Holy Spirit, let us hold fast, without wavering, and do the good works we have been chosen to do.

**Consider**

- Administering a spiritual gift assessment tool to the members of your class to help them understand their service niche.
- Compiling a skills and talents bank to become aware of the resources available to you for mission.
- Brainstorming an outreach program that utilizes the talents of each person in the class.
- Making the word service into an acronym.
- Producing a skit that illustrates the differences between service (church) and service (mission).
- Performing a small-scale needs assessment in your community to assess the field to which you are accountable.

---

_Cadia Daniel, D’Abadie, Trinidad and Tobago._

repository: Adventech/sabbath-school-lessons

branch_name: refs/heads/stage

repo_name: Adventech/sabbath-school-lessons


text:
# Library for Angular 2 - Review UI
This is a basic setup for Angular 2 which allows you to embed a review component in your application.
Sample in below website uses<EMAIL_ADDRESS>
- - -

### Installation

You can install ***angular-review-ui*** using npm:

  ```bash
  npm install angular-review-ui --save
  ```

### Import
```typescript
// In your App's module:
import { ReviewModule, ReviewComponent } from 'angular-review-ui';

imports: [
    ReviewModule
],
declarations: [
    ReviewComponent
]
```

### Systemjs
```typescript
// In systemjs.config.js
map: {
	  'angular-review-ui': 'node_modules/angular-review-ui'
},
packages: {
	'angular-review-ui': {
      main: './index.js',
			defaultExtension: 'js'
		}
}
```

### Simple Review Component

Import `ReviewComponent` in your app. Then you can use `review` component:
```html
<review-component></review-component>
```

### Troubleshooting

Please follow this guidelines when reporting bugs and feature requests:

1. Please **always** write steps to reproduce the error. That way we can focus on fixing the bug, not scratching our heads trying to reproduce it.

Thanks for understanding!

repository: Cimpress-MCP/angular-review-ui

repo_name: Cimpress-MCP/angular-review-ui


text:
# Rick&Morty

This project looks at the Characters and locations from the T.V. show Rick and Morty to provide the user with a list of the people and places included in the award winning show , including: name, their status in the show, species and much more. This information is pulled from https://rickandmortyapi.com/api

## Installation

Add this line to your application's environment file:

```ruby
 gem 'pry' gem 'json'gem 'rest-client' gem 'colorize' gem'vine'

```

And then execute in terminal:

    $ gem install pry -v 0.10.3, gem install json, gem install rest-client, gem install colorize, gem install vine

## Usage

Running ./bin/start will trigger the rest of the program to run. A menu is available at each decision point.

## Development

After checking out the repo, make sure to install the necessary gems listed in installation.

## Contributing

Bug reports and pull requests are welcome on GitHub at https://github.com/csdj92/Rick-and-Morty-CLI. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.

## License

The project is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).


text:
# About `assets` directory

This directory contains web-accessible resources necessary for proper functioning of a QCubed web-app. You should not directly alter contents here. Any changes you make will be overwritten when you upgrade the framework (unless you tell us what you changed and why, using pull requests :relaxed:).

The various assets directory are for assets and helpers for the various
 Controls, including images, javascript files and popups.

Of course, these files can technically be anywhere in the docroot,
 but the current directory location of /assets/* is meant to serve
 as a centrally-available assets location for these Control helpers.

If you want to move them (either individually or entirely),
 be sure to update your `configuration.inc.php` to reflect the new location(s) of the assets. [**HINT**: Look for definition and usages of `__QCUBED_ASSETS__` in the configuration file]

Remember that any additional Control classes that you create or download (manually, not by installing plugins) which may have their own assets should **NOT** have their assets installed in one of these subdirectories because they will be over-written on framework upgrade.

If you need to create your own web-assets (HTML/CSS/JS/Images/Fonts), please use the assets directory in your `project` folder.

repository: qcubed/application

gha_language: PHP

repo_name: qcubed/application


text:
# betterbartapi

A simple wrapper around BART's official API that removes all of the terrible-ness of working with BART's API. https://betterbartapi.herokuapp.com/

## Getting Starting

Before deploying the application, please make sure you have the following installed:
* [pip](https://pip.pypa.io/en/stable/installing/)
* [python 2.7.14](https://www.python.org/downloads/release/python-2714/)

Clone the repo:
```
git clone https://github.com/jchio001/betterbartapi.git
```

Install requirements:
```
pip install requirements.txt
```

Run locally:
```
./scripts/run_local.sh
```

## Built With

* [Flask](http://flask.pocoo.org/)
* [Python 2](https://www.python.org/)

# Contributing

To contribute to this project, clone the repo & submit your changes through a pull request.

## License

This project is licensed under the Apache 2.0 License - see the [LICENSE.txt](https://github.com/jchio001/betterbartapi/blob/master/LICENSE.txt) file for details


text:
# Quick Start Guide

This is an exercise to develop a simple poker scoring application using functional techniques in c#.

Not 100% of all code is purely functional, but it's as close as makes sense for me for what's available in the language.

All primitives are record or record-style classes that have init and read only properties. In a team, this can help keep code functional for longer.

The [CSharpFunctionalExtensions](https://github.com/vkhorikov/CSharpFunctionalExtensions) is for an immutable base class with control over deep equality. Unfortunately records don't allow overwriting the equality operator for handling nested classes (like a nested List or HashSet in this example).

This is a modification of the principles presented in [this](https://edcharbeneau.com/csharp-functional-workshop-instructions/#chapter0) walk-though.

# Prerequisites

1. Install [dotnet core](https://dotnet.microsoft.com/download/dotnet-core) cli
2. Restore packages `dotnet restore`

# Running the Project

Run project normally with `dotnet run`

## Run Tests

Run all tests with `dotnet test`

repository: thebrianbug/CsharpPokerFunctional

repo_name: thebrianbug/CsharpPokerFunctional


text:
CakePHP plugin for Opauth
=========================

CakePHP 3.x plugin for [Opauth](https://github.com/opauth/opauth).

Opauth is a multi-provider authentication framework.

Requirements
---------
- CakePHP >= v3.0
- Opauth >= v1.0

Using [Composer](http://getcomposer.org/)
-----------
You can install CakePHP-Opauth plugin directly from Composer at [wouter0100/cakephp-opauth](http://packagist.org/packages/wouter0100/cakephp-opauth).

How to use
----------
1. Install this plugin using Composer, add `"wouter0100/cakephp-opauth": "*"` to your Composer file and execute `composer update`.

2. Add this line to the bottom of your app's `config/bootstrap.php`:

   ```php
   Plugin::load('Wouter0100/Opauth', ['routes' => true, 'bootstrap' => true]);
   ```

3. Create a `config/opauth.php` file with the URL you wish to use for handeling the authentication data after opauth has run:

   ```php
   <?php

   $config['Opauth']['CompleteURL'] = '/auth/complete';
   ```
   You may want to add `config/opauth.php` to your gitignore, as the file will contain sensitive information.

4. Load [strategies](https://github.com/uzyn/opauth/wiki/list-of-strategies) using Composer for Opauth 1.0.0.

   Append configuration for strategies at your `config/opauth.php` file as follows:
   ```php
   // Using Facebook strategy as an example
   $config['Opauth']['Strategy']['Facebook'] = [
        'app_id' => 'YOUR FACEBOOK APP ID',
        'app_secret' => 'YOUR FACEBOOK APP SECRET'
   ];
   ```

5. Go to `/auth/facebook` to authenticate with Facebook, and similarly for other strategies that you have loaded.

6. After validation, user will be redirected to `'/auth/complete'` (or whatever you chose in the `opauth.php`
   config file) with validated auth response data retrievable available at `$this->response->data`.

   To route a controller to handle the response, at your app's `config/routes.php`, add a connector, for example:

   ```php
   $routes->connect(
       '/auth/complete',
       ['controller' => 'Users', 'action' => 'complete']
   );
   ```

   You can then work with the authentication data at, say `src/Controller/UsersController.php` as follows:

   ```php
   <?php
   namespace App\Controller;

   use App\Controller\AppController;

   class UsersController extends AppController
   {
       public function complete()
       {
           debug($this->request->data);
       }
   }
   ```

   Note that this CakePHP Opauth plugin already does auth response validation for you with its results available
   as a boolean value at `$this->request->data['validated']`.

Issues & questions
-------------------
- Discussion group: [Google Groups](https://groups.google.com/group/opauth)
  _This is the primary channel for support, especially for user questions._
- Issues: [Github Issues](https://github.com/wouter0100/cakephp-opauth/issues)
- Twitter: [@wouter0100](http://twitter.com/wouter0100)
- Email me<EMAIL_ADDRESS>- IRC: **#opauth** on [Freenode](http://webchat.freenode.net/?channels=opauth&uio=d4)

Used this plugin in your CakePHP project? Let us know!

License
---------
The MIT License
Copyright © 2012-2015 U-Zyn Chua (http://uzyn.com), further mentained by Wouter van Os (http://wouter0100.nl)


text:
---
layout: default
---

# 1992-12-18 - Re: The Need for Positive Repuations

## Header Data

From<EMAIL_ADDRESS>(Joe Thomas)

To<EMAIL_ADDRESS>Message Hash: b3e0a84418e9568ac28f6f116b548038bd705ae84a93f392b3d9d545b5963c43

Message ID: \<9212182019.AA00438@kolanut\>

Reply To: _N/A_

UTC Datetime: 1992-12-18 20:20:39 UTC

Raw Date: Fri, 18 Dec 92 12:20:39 PST

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Joe Thomas)
Date: Fri, 18 Dec 92 12:20:39 PST
To<EMAIL_ADDRESS>Subject: Re: The Need for Positive Repuations
Message-ID: <9212182019.AA00438@kolanut>
MIME-Version: 1.0
Content-Type: text/plain

> From<EMAIL_ADDRESS>(Timothy C. May)
> The longterm solution is to use "positive reputations" and not just
> "negative reputations" (as in Kill files). This is something Dean
> Tribble just talked about at our last physical meeting of the
> Cypherpunks ("Bay Area Branch" :-} ).
>

> Think of like a credit rating. People _earn_ trust, they don't just
> get assigned a credit rating until they do something bad.

>From<EMAIL_ADDRESS>(Perry E. Metzger)
>Indeed, in the long run, when there are billions of people in the
>nets, even UseNet newsgroups devoted to people who use musical
>instruments as sex toys would have thousands of posts a day because
>given billions of possible subscribers, finding a few tens of
>thousands with a particularly obscure interest wouldn't be hard.
>Thus, in the long run, the nets will move to "closed" newsgroups and
>mailing lists in which to be a subscriber one will have to be
>explicitly subscribed to a list and will only be able to read with
>one's private key and post by digitally signing messages. In such
>an environment, anonymous abusers will simply be incapable of
>annoying people.

Yes, but there will still need to be a way for new people to join the
lists, (and the net in general) before they've had a chance to "prove
themselves."  Allowing all new id's to post to the whole group on a
probationary basis is unacceptable;  as soon as someone proves
obnoxious enough to kick off they could just start over with a new
id.  The obvious answer is that a moderator will be necessary for all
closed lists that require a positive rep for posting and that don't
wish to be forever limited to their founding members.  After a few
lucid posts passed by the moderator, an individual would gain enough
of a reputation not to be filtered out any longer.

Of course, anyone who's heard Howard Stern fans invade political
call-in shows will realize there's not much that can be done with
those weird people who will spend a lot of time and energy to appear
credible, only to annoy people.

Joe

{% endraw %}
```

## Thread

+ Return to [December 1992](/archive/1992/12)

+ Return to<EMAIL_ADDRESS>(Harry A. B. Shapiro)](/authors/habs_at_acf3_nyu_edu_harry_a_b_shapiro_)"
+ Return to<EMAIL_ADDRESS>(Joe Thomas)](/authors/jthomas_at_kolanut_mitre_org_joe_thomas_)"
+ Return to "[Marc Horowitz <marc@MIT.EDU>](/authors/marc_horowitz_marc_at_mit_edu_)"
+ Return to<EMAIL_ADDRESS>(Timothy C. May)](/authors/tcmay_at_netcom_com_timothy_c_may_)"

+ 1992-12-18 (Fri, 18 Dec 92 12:20:39 PST) - Re: The Need for Positive Repuations -<EMAIL_ADDRESS>(Joe Thomas)_
  + 1992-12-18 (Fri, 18 Dec 92 12:54:54 PST) - [Re: The Need for Positive Repuations](/archive/1992/12/2f6f7940b1e634d0b19384466a682c26910e80068190a4121791714c8baf5e8b) -<EMAIL_ADDRESS>(Harry A. B. Shapiro)_
    + 1992-12-18 (Fri, 18 Dec 92 14:53:18 PST) - [Re: The Need for Positive Repuations](/archive/1992/12/126a4d7c3c8ae22013befee47e5d363e43a47c3ee5136bc9634e8fe4a9b637b9) - _Marc Horowitz<EMAIL_ADDRESS>      + 1992-12-18 (Fri, 18 Dec 92 15:55:47 PST) - [Re: The Need for Positive Repuations](/archive/1992/12/7eaafb865b9d32eba07470f50663c70616e0e89635a61b6c385f0afdb5d15d03) -<EMAIL_ADDRESS>(Timothy C. May)_


text:
# Students list full stack app

## Description

It's a full stack nestjs/nextjs/graphql/postgress/docker app

## How run this app

1. Make sure you have [Docker](https://www.docker.com/get-started) and [Docker Compose](https://docs.docker.com/compose/) installed.
2. Rename `.env.sample` file to `.env` only. Then if you want, change the variables values to your needs.
3. If it's the first time you run this container you'll need to run:

  ```bash
  #create netework first
  ./create-network.sh

  ```

4. To start the container.

  ```bash
  #start container
  docker-compose up
  ```

5. To stop the container.

  ```bash
  #stop container
  docker-compose down
  ```
6. To rebuild image for any new depenecy you inject run
```bash
  #start container
  docker-compose up --build
  ```
### The app will e running on [http://localhost:3000](http://localhost:3000) and graphql playground will be running on [http://localhost:4000/graphql](http://localhost:4000/graphql)

## To run migrations
  With the docker running:
  1. Go to api folder
```bash
 cd ./api
  ```
2. Install dependencies
```bash
  yarn or npm -i
  ```
3. Run
```bash
 yarn migration:run or npm run migration:run
  ```
## To seed some fake data to database
  With the docker running:

1. Go to api folder
```bash
 cd ./api
  ```
2. Install dependencies
```bash
  yarn or npm -i
  ```
3. Run follow script to  insert 100 random students on db
```bash
  yarn run:command seed:students or npm run run:command seed:students
  ```

## Support

## Stay in touch

- Author - [Marcio Tiene](https://github.com/Marcio-Tiene)

## License

This project is [MIT licensed](LICENSE).

repository: Marcio-Tiene/students-list

repo_name: Marcio-Tiene/students-list


text:
```applescript
-- scanl1 :: (a -> a -> a) -> [a] -> [a]
on scanl1(f, xs)
    if 0 < length of xs then
        scanl(f, item 1 of xs, rest of xs)
    else
        {}
    end if
end scanl
```

```js
// scanl1 is a variant of scanl that has no starting value argument
```

```js
// scanl1 :: (a -> a -> a) -> [a] -> [a]
const scanl1 = (f, xs) =>
    xs.length > 0 ? scanl(f, xs[0], xs.slice(1)) : [];
```

url: https://raw.githubusercontent.com/unlocked2412/prelude-jxa/4ea5c6993ed80129792c2737b191bb7f9448b593/Applescript and Javascript parallel functions/scanl1.md


text:
# Summary

* [Instruction](README.md)

* Frontend Deployment
    * [Preparations](frontend-deployment.md#Preparations)
    * [Deployment](frontend-deployment.md#Deployment)
    * [FAQ](frontend-deployment.md#FAQ)

* Backend Deployment
    * [Preparations](backend-deployment.md#Preparations)
    * [Deployment](backend-deployment.md#Deployment)

* [Quick Start](quick-start.md#Quick Start)

* System Use Manual
    * [Operational Guidelines](system-manual.md#Operational Guidelines)
    * [Security](system-manual.md#Security)
    * [Monitor center](system-manual.md#Monitor center)
    * [Task Node Type and Parameter Setting](system-manual.md#Task Node Type and Parameter Setting)
    * [System parameter](system-manual.md#System parameter)

* [Architecture Design](architecture-design.md)

* Front-end development
    * [Development environment](frontend-development.md#Development environment)
    * [Project directory structure](frontend-development.md#Project directory structure)
    * [System function module](frontend-development.md#System function module)
    * [Routing and state management](frontend-development.md#Routing and state management)
    * [specification](frontend-development.md#specification)
    * [interface](frontend-development.md#interface)
    * [Extended development](frontend-development.md#Extended development)

* Backend development documentation
    * [Environmental requirements](backend-development.md#Environmental requirements)
    * [Project compilation](backend-development.md#Project compilation)
* [Interface documentation](http://<IP_ADDRESS>:8888/escheduler/doc.html?language=en_US&lang=en)
* FAQ
    * [FAQ](EasyScheduler-FAQ.md)
* EasyScheduler upgrade documentation
    * [upgrade documentation](upgrade.md)
* History release notes
    * [1.1.0 release](1.1.0-release.md)
    * [1.0.5 release](1.0.5-release.md)
    * [1.0.4 release](1.0.4-release.md)
    * [1.0.3 release](1.0.3-release.md)
    * [1.0.2 release](1.0.2-release.md)
    * [1.0.1 release](1.0.1-release.md)
    * [1.0.0 release]


text:
# Portfolio V1

This is the second iteration of my personal porfolio website.

I don't have this in use anymore, but you can still take a look at the code.

## License

This code is licensed as [MIT](./LICENSE) by [Maikel van Veen](https://github.com/Maikxx).


text:
# Sage One Java API Spring Application (deprecated)

**Please note that this Sample Application is not updated anymore.** To get an overview of all current sample applications
for the Sage Accounting API, please visit https://developer.sage.com/api/accounting/guides/sample_apps/.

Application Setup

Sample application that integrates with Sage One Accounting via the Sage One API.

Update the [application.yml](https://github.com/Sage/sageone_api_spring_sample/blob/master/application.yml) with your client credentials.

## License

This sample application is available as open source under the terms of the
[MIT licence](LICENSE).

Copyright (c) 2020 Sage Group Plc. All rights reserved.

gha_language: Java


text:
#### Cooperative multitasking for Arduino.

You need to copy files to your project folder.
Library files:
* _CustomTypes.h_
* _DeltaTime.h_
* _DeltaTime.cpp_
* _TaskBase.h_
* _TaskDispatcher.h_
* _TaskDispatcher.cpp_

And sketch template:
* _arduino_coop_multitask.ino_
(don't forget to rename it)

Multitasking achieve by creating light tasks and updating them every loop circle.
For create task you have to create class iherited from ```TaskBase```

```c++
#include "TaskBase.h"
class CustomTask: public TaskBase
{
public:
  void setup();
  void loop(unsigned long delta_time);
};
```

```setup``` func will be called from main setup func.
```loop``` func will be called every circle. Parameter ```delta_time``` is time of previous circle.

#### Task must not block control and not call ```dalay``` func.

* Every of tast must be register in ```TaskDispatcher``` __BEFORE__ call of
    ```c++
    TaskDispatcher::getInstance()->setup();
    ```

* You can register your task by
    ```c++
    TaskDispatcher::getInstance()->Register(task);
    ```

* You also can unregister task (it will not to be update after this)
    ```c++
    TaskDispatcher::getInstance()->Unregister(task);
    ```

* You also can use
    ```c++
    DeltaTime::getInstance()->getDeltaTime()
    ```
    It will return time of previous main loop circle (same as ```delta_time```). But you don't need it in ```TaskBase::loop``` func.

This works pretty simple:
DeltaTime calling ```millis``` func and calculate previous circle time.
It update in TaskDispatcher in the beginning of every loop.

TaskDispatcher contains list of registered tasks and call it's ```setup``` in main setup and ```loop``` every main loop.


text:
Yeoman generator that scaffolds out a Zurb Foundation 5 web app.

[![NPM](https://nodei.co/npm/generator-foundation-five.png?downloads=true)](https://nodei.co/npm/generator-foundation-five/)
[![NPM version](https://badge.fury.io/js/generator-foundation-five.png)](http://badge.fury.io/js/generator-foundation-five)
[![Dependency Status](https://david-dm.org/bauschan/generator-foundation-five.png)](https://david-dm.org/bauschan/generator-foundation-five)

## Before you begin

1. Install Node (with npm): http://nodejs.org/#download
2. Install Sass: http://sass-lang.com/download.html
3. Install Compass: http://compass-style.org/

## Usage

- Install it (only once): `npm install -g generator-foundation-five`

- Create a new folder and cd into it: `mkdir foundation-project && cd $_`

- Run `yo foundation-five`

- Run `bower install`

- Run `grunt` to build and `grunt serve` to preview

- Run `grunt dalek` to execute cross browser tests with [dalekjs](http://dalekjs.com/)

## Options

* `--skip-install`

  Skips the automatic execution of `bower` and `npm` after
  scaffolding has finished.

* `--test-framework=[framework]`

  Defaults to `mocha`. Can be switched for
  another supported testing framework like `jasmine`.

## License

[BSD license](http://opensource.org/licenses/bsd-license.php)

repository: bauschan/generator-foundation-five

gha_language: CSS

repo_name: bauschan/generator-foundation-five


text:
# Milestone Map

(C) Andrew Pritchard 2018

Milestone Map is a programme reporting tool that shows the progress of multiple programmes and projects based on key milestones.

It allows programme and delivery managers to view the overall status of programmes and projects within the context of associated "organisational milestones".

Please note that this is not a project management tool but rather a programme reporting tool.

For help on using the tool itself, please visit [the help file](docs/instructions.md).

Key features:
- Able to show the health of individual milestones

## Installation

Clone this repository. Open `src/index.html` for a debug build. A prebuilt copy of the latest stable release will be available at `docs/index.html`.

## Build from source

You will need to install `npm` to build milestoneMap from source. Alternatively, MilestoneMap works without compilation if you open `src/index.html`.

After you have installed npm, navigate to the source directory and run:

```
npm init
make
```

A build of the source will appear in the `dist` directory. To build again, simply run `make`.

repository: cindyhyl/milestoneMap

repo_name: cindyhyl/milestoneMap


text:
korat-go
===

The backend process for [korat](https://github.com/pocke).

It is responsible for searching and storing GitHub issues.

Development
---

```
$ GO111MODULE=on go get github.com/pocke/korat-go

# Setup database
$ korat-go       # To run migration
$ pkill korat-go # Kill the process after a second

# If you need, replace "pocke" with your GitHub account.
$ cd $GOPATH/src/github.com/pocke/korat-go
$ GITHUB_ACCESS_TOKEN=xxx ./dev_seed_data.sh

# start server
$ korat-go
```

Build binaries for each platform
---

```
$ make
```

repository: pocke/korat-go

gha_language: Go

repo_name: pocke/korat-go


text:
# edutls
implementation of rfc8446 TLS 1.3 in pure python (educational purpose)

# design

- as is mainly for education of TLS 1.3 standard published in 2018, it uses almost all of the concepts and key words for naming.every single message is an object which is responsible for serialization/deserialization.

- it implements the protocol process as state machine noted in rfc8446 Appendix A.1(client side).**no server side support yet.**

files layout:

```
edutls/
	|
	|
	alert.py  		--alert message serialize/deserialize
	extension.py	--extensions used in handshake message serialize/deserialize
	handshake.py	--handshake message serialize/deserialize
	record.py		--record protocol. all messages should be encoded in it to transmit
	keys.py			--key derivation implementations
	types.py		--fundamental objects for serialization/deserialization
	tls13.py		--tls1.3 protocol process implemeted as state machine
tests.py	--a simple test for tls1.3 client
```

## client state machine

![client-state-machine](doc/client-state-machine.png)

# test

TLS 1.3 test servers: [tls13-spec test server](https://github.com/tlswg/tls13-spec/wiki/Implementations)

run test: `python -m unittest tests.TLSClientTest.test_client`

# limits

###### Implementations

- Client ✓
- Server x

###### Cipher Suites

- TLS_AES_128_GCM_SHA256 ✓
- TLS_AES_256_GCM_SHA384 ✓
- TLS_CHACHA20_POLY1305_SHA256 ✓
- TLS_AES_128_CCM_SHA256 ✓
- TLS_AES_128_CCM_8_SHA256 ✓

###### Supported Groups Extension

- secp256r1 ✓
- secp384r1 ✓
- secp521r1 ✓
- x25519 ✓
- x448 ✓
- ffdhe2048 ✓
- ffdhe3072 ✓
- ffdhe4096 ✓
- ffdhe6144 ✓
- ffdhe8192 ✓

###### Key Exchange Modes

- (EC)HDE ✓
- PSK-only ✓
- PSK with (EC)DHE ✓

###### Others

- session resumption ✓
- early data ✓
- cookie x
- oid filters x
- post handshake authentication x
- client certificate authentication x
- server certificate verify  x

# Note

if found any bugs, open an issue as you wish.

welcome to contribute to this educational TLS 1.3 python lib.

repository: yufengzjj/edutls

repo_name: yufengzjj/edutls


text:
# disinfection_robot

### Philosophy (leadership statement)
- Community engagement based engineering --> intensively focus on product and service
- Open source & open hardware --> a platform for anyone to learn about robotics and connect with people
- Be open to new ideas and critiques
- Design principle, simple , feasible

### Disinfection Robot architechture
1. Communication (improving)
- WIFI+Bluetooth connection between raspberry pi and any mobile devices using NodeRed
- Serial communication between Pi and Arduino Uno

2. End effector ("achieved")
-  UV light
-  Sprayer

3. Navigation (focus)
- mostly rely on ultrasonic sensor for wall following/obstacle avoidance and infrard sensor for line following
- Simulation software: Webot ( Cyber Robotics)

![does this image show up properly?](C:\Users\GSOHO\Desktop\Picture1)

### [link for a 1 min video](https://youtu.be/DklAGDz4AtY)
### [link for raw picturesvideos](https://drive.google.com/drive/folders/1CXR6q5mwqL5NxeNnCfcUFJ0lyBzkWC9R?usp=sharing)
### [link for literature review](https://docs.google.com/document/d/1W_xQn0CdwW78urU5YeByii7AZVh4l2zxzDyNEFPVSTU/edit?usp=sharing)
### Please use the discussion board if you have any ideas/critques/suggestions
### feel free to send me an e-mail if you have any question --><EMAIL_ADDRESS>### I will be in my ZOOM meeting room every Sunday @ 8pm (EST) to [chat](https://mcmaster.zoom.us/j/2621494308)

# Todo list
- [ ]Linear actuator controlled sprayer
- [ ]Increase durability of the robot platform
- [ ]Different navigation approach  with bumper to increase safety
- [ ]Bluetooth control
- [ ]Control the robot from a different network -- digital ocean server
- [ ]Audio system
- [ ]Wheel encoder, IMU sensor to increase precision
- [ ]Battery monitoring
- [ ]Strengthen Wifi signal
- [ ]Auto docking/ recharging
- [ ]Penetration Test


text:
# Remote-conda

[![travis-ci](https://api.travis-ci.org/danielfrg/remote-conda.svg)](https://travis-ci.org/danielfrg/remote-conda)
[![appveyor](https://ci.appveyor.com/api/projects/status/github/danielfrg/remote-conda?branch=master&svg=true)](https://ci.appveyor.com/project/danielfrg/remote-conda)

Install conda packages in remote hosts

## Installation

Look at the [releases page](https://github.com/danielfrg/remote-conda/releases) for binaries.

## Usage

`remote-conda` is a basic CLI that has the basic conda commands: `install`, `remove`, `list` and follows the same API as conda with some extra options:

- Host/IP (--host/-x). Can be used multiple times
- User (--user/-u) is the username to ssh into the hosts
- Private key (--pkey/-k) to ssh into the hosts
- Pip Path (--conda/-p), useful to manage packages in multiple virtual environments. Default: `/opt/anaconda/bin/conda`

## Examples:

```bash
$ remote-conda install numpy -u ubuntu -k ~/.ssh/key.pem -x myhost1
$ remote-conda remove numpy -u ubuntu -k ~/.ssh/key.pem -x myhost1 -x myhost2

# Another conda location
$ remote-conda list -u ubuntu -k ~/.ssh/key.pem -x myhost1 -p /user/ubuntu/anaconda/bin/conda
```

repository: danielfrg/remote-conda

repo_name: danielfrg/remote-conda


text:
# OAA Services

`oakd` should be reverse-proxied back to via a shibboleth-enabled Apache 2.4 web server, the Apache configuration
for `oakd` should look something like:

```apache
<Location /oakd/>
  AuthType shibboleth
  ShibRequestSetting requireSession 1
  Require valid-user
  ProxyPassInterpolateEnv On
  ProxyPass "http://<IP_ADDRESS>:8111/oakd/" interpolate
  ProxyPassReverse "http://<IP_ADDRESS>:8111/oakd/" interpolate

  # certain Shibboleth attributes should be passed back as headers, it's important
  # that oakd check the remote_address of the connecton to ensure that it's coming
  # from localhost when relying on these as they can be spoofed by other sources
  # if they're coming from localhost though, they can be trusted.
  RequestHeader set "X-Remote-User" %{REMOTE_USER}s
  RequestHeader set "X-Persistent-Id" %{persistent-id}e
  RequestHeader set "X-EPPN" %{eppn}e
  RequestHeader set "X-Display-Name" %{displayName}e
  RequestHeader set "X-Affiliation" %{affiliation}e
  RequestHeader set "X-Shib-Handler" %{Shib-Handler}e
  RequestHeader set "X-Shib-Session-Id" %{Shib-Session-ID}e
</Location>
```

## Oakd Endpoints

`oakd` is the OAA service that runs on the _Central Authority_, the endpoints listed are the full path, excluding
scheme://and.host.name, these are all JSON-RPC endpoints except for `metadata.json`, which does not take any
arguments and just returns metadata information.

### Endpoints that take bearer tokens or do not require authentication

* **/oakd/metadata.json** - The endpoint from which metadata about this oakd configuration
* **/oakd/token/validate** - Indicates if a passed-in token is still valid in a boolean fashion
* **/oakd/token/refresh** - Given an OAR, retrieves a new OAT
* **/oakd/token/agent_retrieve** - Given an OAA id, OR a resource and eppn, kicks off a process whereby an authenticated
principal may release an OAT directly to an agent process.  If the agent is unregistered with the `oakd` service, then
this might trigger an email to the eppn or a notification to kickoff the registration process.  If the agent is already
registered as a `target` wtih the `oakd` instance, however, the OAT may be immediately released, thus serving the request
for access

### Endpoints that require Shibboleth/SAML2 Authentication

* **/oakd/token/retrieve** - Given an OAA ID, retrieves a new OAT for the authenticated user (_requires shib auth_)
* **/oakd/access/request** - The endpoint that users can visit to initiate the _OAR_ process (_requires shib auth_)
* **/oakd/access/list** - Lists OAAs issued for the requesting user (_requires shib auth_)
* **/oakd/agent/authorize** - Given an Agent ID, authorizes a non-web agent to act on your behalf

## StPd Endpoints

`stpd` is the OAA service that runs on a _Resource Provider_

**/stpd/metadata.json**

### Endpoints that require bearer tokens

* **/stpd/token/redeem** - Used to obtain native credentials for a service


text:
This affects the whole framework really. The "framework" itself becomes just the "plugin"/service system

At the core:
- Services

Two "types" of services:
- Singleton / Global services
- Scoped services

Plugins/providers/whatever we call them can have Init Phases.
Each Phase may have different Wait/Block (current plugin system).
Things should be loaded in an order or batched.
To allow dynamic loading (needed for splitting client side bundles):
- Plugins can be loaded at any time
- If a plugin has a Wait and that thing does not exist, Error
- If a plugin has a Block and that thing is already loaded, Error
- A batch-load system should be used to allow loading many things at once and handle Wait/Blocks

```js
PluginManager.batchLoad(() => {
  require('my-plugin-one');
  require('my-plugin-two');
  require('my-plugin-three');
  // ...
});
```

Plugins themselves do stuff and/or provide "services" for others to use/inject.
A plugin may act as a "service provider" by registering serviecs either globally or as a scope.
Though, if a plugin creates a scope, it is responsible for exposing that scope to others who may want it.

```ts
import { Plugin, InitPhase, After, Before } from 'fwsys'

@Plugin
class MyPluginOne {
  @InitPhase
  @Inject(someservice)
  @After('MyPluginTwo:somePhase')
  @Before('MyPluginThree:blockedPhase')
  initPhase(someService) {
    this.exposeService(globalService);

    whenSomethingHappens((value) => {
      this.trigger('some-event', 'hello world');

      let scope = this.generateScope();
      scope.exposeService(svcKey, value);
    });

    // we could, optionally, return something for MyPluginThree:blockedPhase to use
  }

  @Before('some-event')
  beforeSomeEvent(str) {
    // but how to know the order in which the pre-processors occur?
    // I just know, right now, that return changes the value(s) for the event
    // maybe. maybe not. dunno.
    return we.gottaPreProcess(str);
  }

  @After('some-event')
  afterSomeEvent(str) {
    we.actOn(str);
  }

  @After('generate-scope')
  afterScopeGenerated(scope) {
    scope.exposeService(scopedSvcKey, scopedService);
  }
}
export = MyPluginOne;
```


text:
[**Support me with a Follow**](https://github.com/iSimar/followers)

# HackerNews-React-Native

[Hacker News](https://news.ycombinator.com/) reader for iOS and Android, made with [React-Native](https://github.com/facebook/react-native).

## DEMO
[![App Store Button](http://imgur.com/y8PTxr9.png "App Store Button")](https://itunes.apple.com/ca/app/hacker-news-reader-react-native/id1067161633?mt=8)
[![Play Store Button](http://imgur.com/utWa1co.png "Play Store Button")](https://play.google.com/store/apps/details?id=com.hackernews)

## iOS App Preview
![iOS Preview Gif 1](http://imgur.com/8OV8MVj.gif "iOS Preview Gif 1")
![iOS Preview Gif 2](http://imgur.com/9mrmir9.gif "iOS Preview Gif 2")
![iOS Preview Gif 3](http://imgur.com/KuySKlC.gif "iOS Preview Gif 3")

## Android App Preview
![Android Preview Gif 1](http://i.imgur.com/88ZW3Ls.gif "Android Preview Gif 1")
![Android Preview Gif 2](http://i.imgur.com/DWjd4zM.gif "Android Preview Gif 2")

##Features/Components
- Uses React Native 0.31
- Pull down to Refresh listview
- Pagination listview
- Comment & Sub Comments
- WebView to view source pages

##Installation
Once you have downloaded or cloned this repository, run `npm install` inside the directory.

##Usage
- [Install XDE](https://docs.getexponent.com/versions/latest/introduction/installation.html), and open the project in it. Then you can access it through the Exponent client for [iPhone](https://itunes.com/apps/exponent) or [Android](https://play.google.com/store/apps/details?id=host.exp.exponent), or simulator from within XDE.

repository: FTD-ZF/HackerNews-React-Native

repo_name: FTD-ZF/HackerNews-React-Native


text:
# Configuration

## Overview

There are two different ways to define configuration in Artifactory Cleanup:

* In a [configuration file](#configuration-file)
* As [environment variables](#environment-variables)

These ways are evaluated in the order listed above.

If no value was provided for a given option, a default value applies. Moreover, if an option has sub-options, and
any of these sub-options is not specified, a default value will apply as well.

## Configuration file

At startup, Artifactory Cleanup searches for a file named `artifactory-cleanup.yml` (or `artifactory-cleanup.yaml`) in:

* `/etc/artifactory-cleanup/`
* `$XDG_CONFIG_HOME/`
* `$HOME/.config/`
* `.` _(the working directory)_

You can override this using the [`--config` flag or `CONFIG` env var](../usage/cli.md).

??? example "artifactory-cleanup.yml"
    ```yaml
    artifactory:
      url: "https://artifactory.example.com"
      apiKey: "01234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ"

    policies:
      -
        name: "mypolicy"
        repos:
          - "rpm-prod-local"
          - "rpm-local"
          - "generic-local"
        schedule: "*/30 * * * *"
        retention: "24h" # 1d
        lastModified: true
        lastDownloaded: true
        common:
          include:
            - "prod/*"
          exclude:
            - "*2.2.*"
            - "*2.1.0*"
    ```

## Environment variables

All configuration from file can be transposed into environment variables. As an example, the following configuration:

??? example "artifactory-cleanup.yml"
    ```yaml
    artifactory:
      url: "https://artifactory.example.com"
      apiKey: "01234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ"

    policies:
      -
        name: "mypolicy"
        repos:
          - "rpm-prod-local"
          - "rpm-local"
          - "generic-local"
        schedule: "*/30 * * * *"
        retention: "24h" # 1d
        lastModified: true
        lastDownloaded: true
        common:
          include:
            - "prod/*"
          exclude:
            - "*2.2.*"
            - "*2.1.0*"
    ```

Can be transposed to:

??? example "environment variables"
    ```
    ATFCLNP_ARTIFACTORY_URL=https://artifactory.example.com
    ATFCLNP_ARTIFACTORY_APIKEY=01234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ

    ATFCLNP_POLICIES_0_NAME=mypolicy
    ATFCLNP_POLICIES_0_REPOS=rpm-prod-local,rpm-local,generic-local
    ATFCLNP_POLICIES_0_SCHEDULE=*/30 * * * *
    ATFCLNP_POLICIES_0_RETENTION=24h
    ATFCLNP_POLICIES_0_LASTMODIFIED=true
    ATFCLNP_POLICIES_0_LASTDOWNLOADED=true
    ```

## Reference

* [artifactory](artifactory.md)
* [policies](policies.md)

repository: syllogy/artifactory-cleanup

repo_name: syllogy/artifactory-cleanup


text:
Contribution Guidelines
-----------------------

First off, thanks for taking the time to contribute :)

#### **Did you find a bug?**

* **Ensure the bug was not already reported** by searching on GitHub under [Issues](https://github.com/rjaros87/chef-expect/issues).
* If you're unable to find an open issue addressing the problem, [open a new one](https://github.com/rjaros87/chef-expect/issues/new).
* Provide sufficient information about how to reproduce problems.

#### **Did you write a patch that fixes a bug or adds a new feature or changes an exist one?**

1. Fork the project.
2. Create a named feature branch (like `add_component_x`)
3. Write your change
4. Write tests for your change (if applicable)
5. Execute kitchen test (Mac OS box require VirtualBox Extension Pack), rubocop, foodcritic.
5. Send pull request from custom branch with clearly description.

gha_language: Ruby


text:
# food-delivery-application
Food delivery application created using Python, Flask, html, css, and MySQL. This project was done using SCRUM style agile software development with a group of 6 people. This repository has been moved from the original locked repository into this one, thus the git history is brief.

# A comprehensive overview of the project
See Project_Documentation_M5_folder_team_01.pdf for full documentation of the process of this project. For a view of the site UI please see page 66 of this document.

# To run
Install PyCharm. (Professional 2020.3+ required)
* Database setup
1. First open MySQL Workbench
2. Create a new query tab in MySQL Workbench
3. Copy the database code from database.schema in
```application/foodApp/schema.sql```
4. Paste all of the code into your MySQL Workbench query tab
5. Run the query tab
* Running the server on localhost
1. Open app.py
```application/foodApp/app.py```
2. Configure the python interpreter and run the application
3. Navigate the site

*Please note that a requirements.txt file is not yet available. In an upcoming version this list of dependencies will be available.*


text:
This section documents the work-in-progress Rust language team decision
process. This process, and the `rustbot` tooling to support it, does not yet
have a finished implementation. This document serves to explain the intended
process, for the purposes of ongoing implementation.

## Prioritized principles of Rust team consensus decision-making

These are in order of priority. They're intended to be general enough that they
could apply to any Rust governance team, not just the language team.

- **Treasure dissent.** When someone raises a concern, that's a chance to
  improve the design, and to discover and explore underlying values. Dissent
  should be an amicable, cooperative process.
- **Understand and cooperatively resolve concerns.** We cannot resolve a
  concern without first understanding it, including the underlying values
  motivating it. We should demonstrate that understanding by documenting the
  concern. We should consider the tradeoffs and the impacts on users, through
  the Rust design principles. We should seek out and favor satisfying solutions
  (those that satisfy everyone's values) over
  [satisficing](https://en.wikipedia.org/wiki/Satisficing) solutions (those
  that are just good enough for people to accept them as a compromise among
  conflicting values, without actually being happy with the outcome).
- **Don't force an irreversible decision.** We should make decisions
  reversible whenever we can. When making a necessarily irreversible decision
  (e.g. stabilizing a feature), we should pay close attention to dissent, and
  hesitate before overriding objections. If possible, we should seek a better
  alternative, or seek common ground we can find consensus on, or seek an
  intermediate step that addresses the same use case and supports evaluation
  for a more informed decision in the future. If none of those are possible,
  consider the null alternative; not making a change should always be the
  easier path, and the burden of proof to override a concern on an irreversible
  decision should be high.
- **Value expertise.** When cooperatively resolving a concern, or when
  considering overriding a concern, carefully weigh the advice and
  recommendations of experts. This includes team advisors, domain experts, and
  the owners or members of relevant initiatives.
- **Recording reasoning helps ensure good, consistent decisions over time.**
  Even if we decide not to sustain an objection, we should always record the
  objection and the reasons for our decision as a "dissent", as well as any
  unresolved questions for evaluation later in the process. The team member who
  raised the objection has the perogative to author that dissent and frame the
  unresolved questions (within reason).
- **Consensus doesn't mean unanimity.** Consensus means everyone is heard and
  understood, and all concerns are addressed (even those not treated as
  blocking), and the team finds the outcome reasonable. Consensus does not mean
  everyone agrees completely.

## Consensus decision-making process

First, see [some examples of the decision-making process in
action](./decision_process/examples.md). Then, read the [decision process
reference](./decision_process/reference.md) for the full process and the
`rustbot` tooling to support it.

repository: rust-lang/lang-team

repo_name: rust-lang/lang-team