text:
---
title: Manage Environments - Cloud Service
description: Manage Environments - Cloud Service
exl-id: 93fb216c-c4a7-481a-bad6-057ab3ef09d3
---
# Managing Environments {#manage-environments}

The following section describes the types of environment a  user can create and how the user can create an environment.

## Environment Types {#environment-types}

A user with the requisite permissions can create the following environment types (within the bounds of what is available to the specific tenant).

* **Production and Stage Environment**:
The Production and Stage is available as a duo and is used for testing and production purposes.

* **Development**: A Development environment can be created for development and testing purposes and will be associated with non-production pipelines only.

  >[!NOTE]
  >A Development environment that is auto-created in a Sandbox program will be configured to include Sites and Assets solutions.

  The following table summarizes Environment types and their attributes:

   |Name|Author Tier|Publish Tier|User Can create| User can delete|Pipeline which can be associated with environment|
   |--- |--- |--- |--- |---|---|
   |Production |Yes |Yes if Sites included |Yes |No|Production pipeline|
   |Stage |Yes |Yes if Sites included |Yes |No|Production pipeline|
   |Development |Yes |Yes if Sites included |Yes |Yes|Non-production pipeline|

   >[!NOTE]
   >The Production and Stage is available as a duo and is used for testing and production purposes.  User will not be able to create only Stage or only Production environment.

## Adding Environment {#adding-environments}

1. Click on **Add Environment** to add an environment. This button will be accessible from the **Environments** screen.
   ![](assets/environments-tab.png)

    The **Add Environment** option is also available on the **Environments** card when there are zero environments in the program.

    ![](assets/no-environments.png)

   >[!NOTE]
   >The **Add Environment** option will be disabled based on lack of permissions or what may be contracted.

1. The **Add environment** dialog box appears.The user needs to submit details such as **Environment type** and **Environment name** and **Environment description** (depending upon the user’s objective in creating the environment within the bounds of what is available to the specific tenant).

   ![](assets/add-environment2.png)

   >[!NOTE]
   >When creating an environment, one or more *integrations* are created in Adobe I/O. These are visible to customer users who have access to the Adobe I/O Console and must not be deleted. This is disclaimed in the description in the Adobe I/O Console.

   ![](assets/add-environment-image1.png)

1. Click **Save** to add an environment with the populated criteria.  Now the *Overview* screen  displays the card from where you can set up  your pipeline.

   >[!NOTE]
   >In case, you have not yet set up your non-production pipeline, the *Overview* screen  displays the card from where you can create your non-production pipeline.

## Environment Details {#viewing-environment}

The **Environments** card on the Overview page lists up to three environments.

1. Select the **Show All** button to navigate to the **Environment** summary page to view a table with a complete list of environments.

   ![](/help/implementing/cloud-manager/assets/environment-showall.png)

1. The **Environments** page displays the list of all the existing environments.

   ![](assets/environment-view-2.png)

1. Select any one of the environments from the list to view the environment details.

   ![](assets/environ-preview1.png)

### Accessing Preview Service {#access-preview-service}

Preview Service feature delivers an additional Preview (publish) Service to each AEM as a Cloud Service environment via Cloud Manager.

Preview a website's final experience before it reaches the publish environment and is available publicly. A few pointers before you you can see and use Preview Service:

1. **AEM Version**: Your environment must be on AEM version `2021.05.5368.20210529T101701Z` or higher. Make sure an update pipeline has successfully run on your environment to accomplish this.

1. **Default IP Allow List Lock**: Upon creation, the Preview Service will have a default IP Allow List applied to it, labeled `Preview Default [Env ID]`.

   >[!NOTE]
   >Upon first creation, you must actively unapply the default IP Allow List from the Preview Service in your environment in order to enable access.

   A user with requisite permissions must do one of the following in order to *unlock* access to Preview Service and provide the desired access:

   * Create an appropriate IP Allow List and apply it to the Preview Service. Follow this immediately by unapplying `Preview Default [Env ID] IP Allow List` from the Preview Service. Refer to [UnApplying an IP Allow List](/help/implementing/cloud-manager/ip-allow-lists/unapply-ip-allow-list.md) for more details.

      *OR*,

   * Use the update IP Allow List workflow to remove the default IP and add IP(s) as appropriate. Refer to [Viewing and Updating an IP Allow List](/help/implementing/cloud-manager/ip-allow-lists/view-update-ip-allow-list.md) to learn more.

      >[!NOTE]
      >The above steps must be done in advance of sharing the preview service URL with any of your teams in order to ensure the appropriate members of your team are able to access the preview URL.

      Once access to preview service is unlocked, the lock icon (as shown in the figure below) will no longer be displayed.

      ![](/help/implementing/cloud-manager/assets/preview-service1.png)

1. **Publish Content to Preview**: You can publish content to the Preview Service by using the Manage Publication UI inside AEM. Refer to [Previewing Content](https://experienceleague.adobe.com/docs/experience-manager-cloud-service/sites/authoring/fundamentals/previewing-content.html?lang=en) for more details.

## Updating Environment {#updating-dev-environment}

Updates of Stage and Production environments are automatically managed by Adobe.

Updates to Development environments are managed by users of the program. When an environment is not running the latest publicly available AEM release, the status on Environments Card on the Home Screen will show **UPDATE AVAILABLE**.

![](assets/environ-update.png)

The **Update** option is available from the **Environments** Card.
This option is also available, if you click on **Details** from the **Environments** card. The **Environments** page opens and once you select the Development environment, click on **...** and select **Update**, as shown in the figure below:

![](assets/environ-update2.png)

Selecting this option will allow a Deployment Manager to update the pipeline associated with this environment to the latest release and then execute the pipeline.

If the pipeline has already been updated, the user is prompted to execute the pipeline.

## Deleting Environment {#deleting-environment}

User with the requisite permissions will be able to delete a Development environment.

The **Delete** option is available from the dropdown menu in the **Environments** Card. Click on **...** for a Development environment you want to delete.

![](assets/environ-delete.png)

The delete option is also available, if you click on **Details** from the **Environments** card. The **Environments** page opens and once you select the Development environment, click on **...** and select **Delete**, as shown in the figure below:

![](assets/environ-delete2.png)

>[!NOTE]
>This feature is not available for Production/Stage environment set in a Production program set up for production purposes. The feature is, however, available for Production/Stage environments in a Sandbox program.

## Managing Access {#managing-access}

Select **Manage Access** from the dropdown menu in the **Environments** Card. You can navigate to the author instance directly and manage access for your environment.

![](assets/environ-access.png)

## Accessing Developer Console {#accessing-developer-console}

Select **Developer Console** from the dropdown menu in the **Environments** Card. This will open a new tab in your browser with the login page to **Developer Console**.

Only a user in the Developer role will have access to **Developer Console**. The exception being for Sandbox Programs, where any user with access to the Cloud Manager Sandbox Program will have access to **Developer Console**.

Refer to [Hibernating and De-hibernating Sandbox Environments](https://experienceleague.adobe.com/docs/experience-manager-cloud-service/onboarding/getting-access/cloud-service-programs/sandbox-programs.html#hibernating-introduction) for more details.

![](assets/environ-devconsole.png)

This option is also available, if you click on **Details** from the **Environments** card. The **Environments** page opens and once you select an environment, click on **...** and select **Developer Console**.

## Login Locally {#login-locally}

Select **Local Login** from the dropdown menu in the **Environments** Card to login locally to Adobe Experience Manager.

![](assets/environ-login-locally.png)

Additionally, you can login locally from the **Environments** summary page.

![](assets/environ-login-locally-2.png)

## Managing Custom Domain Names {#manage-cdn}

Navigate to the **Environments** details page from the Environments Summary page.

>[!NOTE]
>Custom Domain Names are now supported in Cloud Manager for Sites programs for both Publish and Preview Services. Each Cloud Manager Environment can host up to a maximum of 250 custom domains per environment.

The following actions can be performed on the Publish service for your environment  as described below:

1. [Adding a Custom Domain Name](/help/implementing/cloud-manager/custom-domain-names/add-custom-domain-name.md)

1. [Viewing and Updating a Custom Domain Name](/help/implementing/cloud-manager/custom-domain-names/view-update-replace-custom-domain-name.md)

1. [Deleting a Custom Domain Name](/help/implementing/cloud-manager/custom-domain-names/delete-custom-domain-name.md)

1. [Checking Status of Custom Domain Name](/help/implementing/cloud-manager/custom-domain-names/check-domain-name-status.md#pre-existing-cdn) or an [SSL Certificate](/help/implementing/cloud-manager/managing-ssl-certifications/check-status-ssl-certificate.md#pre-existing-cdn).

1. [Checking Status of an IP Allow Lists](/help/implementing/cloud-manager/ip-allow-lists/check-ip-allow-list-status.md#pre-existing-cdn)

## Managing IP Allow Lists {#manage-ip-allow-lists}

Navigate to the Environment details page from the Environments Summary page. You can perform the following actions on the Publish and/or Author service(s) for your environment here.

>[!NOTE]
>IP Allow List feature is now supported in Cloud Manager for Author, Publish, and Preview Services (available in Sites programs).

### Applying an IP Allow List {#apply-ip-allow-list}

Applying an IP Allow List is the process by which all IP ranges included in the definition of the Allow-List are associated with an Author or Publish service in an environment. A user in the Business Owner or Deployment Manager role must be logged in in order to be able to apply an IP Allow List.

>[!NOTE]
>The IP Allow List must exist in Cloud Manager in order to apply it to an environment-service. To learn more about IP Allow Lists in Cloud Manager navigate to [Introduction to IP Allow Lists in Cloud Manager](/help/implementing/cloud-manager/ip-allow-lists/introduction.md).

Follow the steps below to apply an IP Allow List:

   1. Navigate to the specific environment from the **Environments** details page and navigate to the **IP Allow Lists** table.
   1. Use the input fields at the top of the IP Allow List table to select the IP Allow List and the Author or Publish service you wish to apply it to.
   1. Click on **Apply** and confirm your submission.

### Unapplying an IP Allow List {#unapply-ip-allow-list}

Unapplying an IP Allow List is the process by which all IP ranges included in the definition of the Allow  List are disassociated from an Author or Publisher service in an environment. A user in the Business Owner or Deployment Manager role must be logged in in order to be able to Unapply an IP Allow List.

Follow the steps below to unapply an IP Allow List:

1. Navigate to the specific **Environments** details page from Environments screen and navigate to the **IP Allow Lists** table.
1. Identify the row where the IP Allow List rule you wish to unapply is listed.
1. Select the **...** menu from the far right end of the row.
1. Select the **Unapply** option and confirm your submission.


text:
# blynkkk/blynkkk.github.io

Organize your issues with project boards

Did you know you can manage projects in the same place you keep your code? Set up a project board on GitHub to streamline and automate your workflow.

![get organized](https://github.githubassets.com/images/modules/projects/octicon-get-organized.svg)

Sort tasks

Add issues and pull requests to your board and prioritize them alongside note cards containing ideas or task lists.

![plan project](https://github.githubassets.com/images/modules/projects/octicon-plan-project.svg)

Plan your project

Sort tasks into columns by status. You can label columns with status indicators like "To Do", "In Progress", and "Done".

![automate workflow](https://github.githubassets.com/images/modules/projects/octicon-automate-workflow.svg)

Automate your workflow

Set up triggering events to save time on project management—we’ll move tasks into the right columns for you.

![track progress](https://github.githubassets.com/images/modules/projects/octicon-track-progress.svg)

Track progress

Keep track of everything happening in your project and see exactly what’s changed since the last time you looked.

![share status](https://github.githubassets.com/images/modules/projects/octicon-share-status.svg)

Share status

Each card has a unique URL, making it easy to share and discuss individual tasks with your team.

![finish project](https://github.githubassets.com/images/modules/projects/octicon-finish-project.svg)

Wrap up

After you wrap up your work, close your project board to remove it from your active projects list. On to the next project!

license: MIT

branch_name: refs/heads/master

extension: md

gha_language: JavaScript

gha_license_id: NOASSERTION

license_type: permissive


text:
---
title: Requirements
weight: 3
---

The laravel-dashboard package requires **PHP 7.4+**,  **Laravel 8+** and **Livewire 2+** .

This package uses `json` columns. MySQL 5.7 or higher is required.

repository: spatie/laravel-dashboard

branch_name: refs/heads/main

gha_language: PHP

gha_license_id: MIT

repo_name: spatie/laravel-dashboard


text:
---
displayed_sidebar: entitiesSidebar
---

# Enumeration: UserRoles

## Enumeration Members

### ADMIN

• **ADMIN** = ``"admin"``

#### Defined in

[models/user.ts:8](https://github.com/medusajs/medusa/blob/da7ea8c5d/packages/medusa/src/models/user.ts#L8)

___

### DEVELOPER

• **DEVELOPER** = ``"developer"``

#### Defined in

[models/user.ts:10](https://github.com/medusajs/medusa/blob/da7ea8c5d/packages/medusa/src/models/user.ts#L10)

___

### MEMBER

• **MEMBER** = ``"member"``

#### Defined in

[models/user.ts:9](https://github.com/medusajs/medusa/blob/da7ea8c5d/packages/medusa/src/models/user.ts#L9)

repository: medusajs/medusa

branch_name: refs/heads/develop

gha_language: TypeScript

repo_name: medusajs/medusa


text:
# Introduction

## What is Ream?

Ream is a minimal framework for building server-rendered or static website using Vue.js under the hood. Unlike other popular SSR frameworks, Ream is designed to be more low-level, which means it does not enforce a specific folder structure. In other words, it's pretty similar to a normal SPA, it's possible to migrate a vue-cli or [Poi](https://poi.js.org) app to Ream in minutes!

There's only one basic concept:

You create an app by populating an entry file, says `index.js`. It will be server-rendered so that the initial rendering will be faster than a normal SPA, after that the client-side app will take over it.

If you'd like to learn and build a website with Ream, keep reading and you'll get there pretty fast.

## Why the name?

It's somehow inspired by the famous twins __Rem__ and __Ram__ from anime world. __Rem__ is like the client-side and __Ram__ is like the server-side, they cannot live without each other.

## Getting started

If you haven't installed Ream inside your project, please navigte to [installation guide](./installation.md) first.

Configure your npm scripts in `package.json`:

```json
{
  "scripts": {
    "start": "ream start",
    "dev": "ream dev",
    "build": "ream build"
  }
}
```

::: tip
By default Ream looks for files in current working directory `.`, if you prefer another one you can change the base directory like so: `ream dev ./path/to/dir`.
:::

Then populate an entry file at `./index.js` (relative to the base directory):

```js
import Vue from 'vue'
import Router from 'vue-router'

Vue.use(Router)

export default () => {
  const router = new Router({
    mode: 'history',
    routes: [
      {
        path: '/',
        component: () => import('./views/index.vue')
      }
    ]
  })

  return {
    router
  }
}
```

The entry file must export a function that returns an object.

And the `index.vue` component:

```vue
<template>
  <div>Hello Ream!</div>
</template>
```

Now you can run `yarn dev` to start development server to preview your server-rendered website.

repository: ream/website

repo_name: ream/website


text:
# Spotaroom

## How to use this repo

This project was bootstrapped with [Create React App](https://github.com/facebook/create-react-app). In order to make it work, first you need to have a package manager installed, such as npm in [Node.js](https://nodejs.org/) or [Yarn](https://yarnpkg.com/lang/en/). Then you'll need to install `create-react-app` globally:

`$ npm install -g create-react-app`

or

`$ yarn install -g create-react-app`

Now you can:

1. Clone the repo.
2. Install the dependencies by running `$ npm install` / `$ yarn install`.
3. In the project directory, type `$ npm start` / `$ yarn start` to run the app in the development mode.
4. Open [http://localhost:3000](http://localhost:3000) to view it in the browser.
5. Start coding! :)

### Production build

To build the app for production, run `$ npm run build` / `$yarn build` to create the build folder. If you also want to publish the production version in GitHub Pages, follow the next steps **before running the build command**:

1. Make sure the package.json includes the following field: `"homepage": "./"`. This is a **very important step**!!! It's necessary to make the file routes relative to our files. Otherwise the scripts, images and other resources won't be properly compiled.
2. All the http resources should be **https**. For example, image urls, API requests...
3. Now you can run `$ npm run build` / `$yarn build`.
4. Run `$ mv build docs`. This change in the folder name is necessary for GitHub Pages to recognise the build version.
5.  :)

### Testing the app

Run `$ npm test` / `$ yarn test` to launch the test runner included in Create React App. For the moment, there's only a test for the App component.

repository: lauraferrandof/spotaroom

repo_name: lauraferrandof/spotaroom


text:
---
page_type: sample
languages:
- java
products:
- azure
description: "This is a sample applicaiton to showcase the use of Spring Cloud Function on top of Azure Functions."
urlFragment: hello-spring-function-azure
---

# Example "Hello, world" Spring Boot application that runs on Azure Functions

This is a sample applicaiton to showcase the use of Spring Cloud Function on top of Azure Functions.

## Features

This is just a "Hello, world", but it uses domain objects so it's easy to extend to do something more complex.

## Getting Started

### Prerequisites

This project uses the Maven Wrapper, so all you need is Java installed.

### Installation

- Clone the project: `git clone https://github.com/Azure-Samples/hello-spring-function-azure.git`
- Build the project: `./mvnw clean package`

### Quickstart

Once the application is built, you can run it locally using the Azure Function Maven plug-in:

`./mvnw azure-functions:run`

And you can test it using a cURL command:

`curl http://localhost:7071/api/hello -d "{\"name\":\"Azure\"}"`

## Deploying to Azure Function

Deploying the application on Azure Function with the Azure Function Maven plug-in:

`./mvnw azure-functions:deploy`


text:
# Football Manager 2021
A Football Manager Application built on Javafx, containing authentic information and images of more than 16700 players from over 660 clubs and 160 countries, collected from [fifacm](https://www.fifacm.com). This was done as our L1T2 Term Project on JavaFX and Java Networking.

[![Football Manager 2021](https://github.com/Sadat-Hossain-01/football-manager-2021/blob/main/screenshots/thumbnail.png)](https://youtu.be/FVec1-C2mgQ "Football Manager 2021")

## Run
[Download](https://github.com/Sadat-Hossain-01/football-manager-2021/releases/download/v1.0/football-manager-2021.zip) the [release](https://github.com/Sadat-Hossain-01/football-manager-2021/releases/tag/v1.0). Unzip the compressed file and extract. Run server.jar first and then as many instances of client.jar as you like.

## From Command Line
Use the following commands.
```
java -jar server.jar
java -jar client.jar
```
To save the transfers and progress, close the server by writing `stop` in the terminal where the server is running.

## Login

https://user-images.githubusercontent.com/57341381/127739539-b69188e7-9aa4-4313-b46d-99e154ba5d8c.mp4

## Change Password

https://user-images.githubusercontent.com/57341381/127739940-6f917127-bf69-4c52-8c4f-953b655bbb8f.mp4

## Detailed Display of Player's Information

![Lionel Messi](https://github.com/Sadat-Hossain-01/football-manager-2021/blob/main/screenshots/Messi.png "Lionel Messi")
![Cristiano Ronaldo](https://github.com/Sadat-Hossain-01/football-manager-2021/blob/main/screenshots/Ronaldo.png "Cristiano Ronaldo")
![Neymar](https://github.com/Sadat-Hossain-01/football-manager-2021/blob/main/screenshots/Neymar.png "Neymar Jr.")

## Player Search Options

![Search Options](https://github.com/Sadat-Hossain-01/football-manager-2021/blob/main/screenshots/Search%20Options.png "Player Search Options")

https://user-images.githubusercontent.com/57341381/127751404-35114304-3578-4a0a-8ce9-65b3237768e8.mp4

## Realtime Update of Search Results

https://user-images.githubusercontent.com/57341381/127760534-53b270ce-a884-4a26-a6e3-cd9f22dc0801.mp4

## Player Transfer Demonstration

https://user-images.githubusercontent.com/57341381/127739589-5655d9cf-6106-4a89-8caf-4f182b113635.mp4


text:
# Stereum craspedium (Fr.) Burt, 1920 SPECIES

#### Status
SYNONYM

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

#### Published in
Ann. Mo. bot. Gdn 7: 113 (1920)

#### Original name
Thelephora craspedia Fr., 1851

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Basidiomycota/Agaricomycetes/Polyporales/Meripilaceae/Hydnopolyporus/Hydnopolyporus fimbriatus/ Syn. Stereum craspedium/README.md

repo_name: mdoering/backbone


text:
# Developing trainlog

To get started, we'd recommend:

```bash
python3 -m venv .venv
source .venv/bin/activate
pip install --upgrade setuptools wheel
pip install -r requirements-dev.txt

./run --help
./run
```

Note that the `./run` script wraps all our standard tasks & makes it easy to run the vast swathe of tools we're keen to use.

repository: DouglasOrr/TrainLog

repo_name: DouglasOrr/TrainLog


text:
---
layout: post
title: "#007 - Map vectorization method"
---

Described here is a method to extract the intertidal surface area from old maps, and georectify it into a modern grid to compare with modern datasets (e.g. cartographic shapefiles, remote sensing imagery, altimetry scans).

First the map is imported into Photoshop, and converted to grayscale. Using the Pen tool at 1px width and red RGB color, the entire span of the high tide line and low tide lines are traced. The Pen tool saves each stroke as a vector, which can be infinitely scaled.

![](/images/MapStep1.png)

If the map has latitude and longitude grid lines, the intersections are marked with small drawn red crosses. All intersections must be marked, to create the lattice that represents the paper itself, which can help later to resolve distortions. Once all tracing is complete, the shapefiles are imported into a new 600dpi 3000x3000 pixel canvas, and the shapefiles enlarged till they fill the entire surface. This maximizes resolution while optimizing for noise reduction - when importing into Matlab close to 99% of the weight of the original image will be removed.

![](/images/MapStep3.png)

In Matlab, the high resolution map is converted into X and Y vectors, keeping only the pixels with data. This point cloud can now be georectified by picking the four corner cross marks (each a key grid intersection) and extracting their X and Y point index. These four image indices are paired with the four equivalent latitude and longitude WGS decimal values. With these four pairs, a projective transformation matrix is calculated. This T-matrix can be multiplied intoto all indices of the point cloud at once, bringing the X and Y vectors into longitude and latitude georectified space, respectively.

Each map is unique, so there is no guarantee that the grid corresponds to modern geodetic standards. Further fine tuning requires control points, or specific regions of the map that are known to be unchanged, such as islands, rocky shoreline regions, or century-old streets and buildings.

![](/images/MapStep4.png)


text:
1. Run script get_model.sh in tools/script and then make sure MNN models' ready.

   ```
   ./get_model.sh
   ```

2. Pod update in demo/iOS path

   ```
   cd demo/iOS
   pod update
   ```

repository: qipengwang/Melon

repo_name: qipengwang/Melon


text:
---
title: "Release Apache APISIX 2.9"
author: "Zexuan Luo"
authorURL: "https://github.com/spacewander"
authorImageURL: "https://avatars.githubusercontent.com/u/4161644?v=4"
keywords:
- APISIX
- Apache APISIX
- Release Notes
description: Apache APISIX version 2.9 is released!
tags: [Release]
---

> Apache APISIX version 2.9 is released!

<!--truncate-->

Apache APISIX version 2.9 is officially released! 🎉 This release has 30+ developers, 100+ PR submissions, 2 new features, and further improved support for plugins, come and learn about the new features in Apache APISIX 2.9!

## New Plugin: authz-casbin

The Casbin community has contributed [authz-casbin](https://github.com/apache/apisix/blob/d9b928321fcdd12eef024df8c7c410424c1e0c8b/docs/en/latest/) to APISIX plugins/authz-casbin.md) plugin to APISIX, and in the new APISIX 2.9 release, APISIX can combine Casbin to do granular permission management at the route level.

Casbin is an open source access control framework that supports configuration to decide whether to allow a certain access operation. With the authz-casbin plugin, we can do multiple roles of access control in one route at the same time.

This control can be set either through a configuration file or through the APISIX Control Plane; it can take effect for a given route or set global defaults. It is very flexible.

If you are interested in this plugin, you are welcome to read [Authorization with Casbin in Apache APISIX](https://apisix.apache.org/blog/2021/08/25/Auth-with-Casbin-in-Apache-APISIX).

## New Feature: Dynamic Configuration of real-ip at Route Level

Apache APISIX version 2.9 now supports dynamic configuration of real-ip at the route level!

The new version adds the [real-ip](https://apisix.apache.org/zh/docs/apisix/plugins/real-ip/) plugin, which dynamically changes the IP and port of the client seen by APISIX.

We can use this plugin to dynamically set real-ip parameters.

```JSON
{
    "plugins": {
        "real-ip": {
            "source": "http_x_forwarded_for",
            "trusted_addresses": ["<IP_ADDRESS>/24"]
        }
    }
}
```

## Improvement: External Plug-in Mechanism

Apache APISIX version 2.9 further improves the support for external plugins with two major changes:

1. When sending a plugin configuration to Plugin Runner, a unique key is sent. because APISIX is a multi-process architecture, in the past, a plugin configuration was sent several times, causing Plugin Runner to update the plugin configuration repeatedly. Now, with this unique key, Plugin Runner can identify duplicate configurations. This makes it possible to implement a plug-in inside Plugin Runner that limits flow!

2. Add a mechanism to get APISIX information from Plugin Runner in the reverse direction. In addition to the request header and request path information sent from APISIX to Plugin Runner, Plugin Runner can also query information from APISIX in the reverse direction. The Var API has been implemented in the Go Plugin Runner implementation to use this mechanism to get information about Nginx variables such as the request_time of the request.

The [Go Plugin Runner](https://github.com/apache/apisix-go-plugin-runner/tree/6f249010b83a124bc30e940635db7fa0838e2c4a), which includes this change, will be released next week Version 0.2.0 will be released next week, so stay tuned!

## Improvement: Existing Plug-ins Enhancement

APISIX version 2.9 improves the functionality of existing plugins with two major changes:

1. the [request-id](https://apisix.apache.org/docs/apisix/plugins/request-id/) plugin supports ID generation via the snowflake algorithm. the snowflake ID generation algorithm is a distributed ID generation mechanism, which generates The snowflake ID generation algorithm is a distributed ID generation mechanism that combines machine IDs, timestamps, and generation sequences. We use etcd to ensure that each worker is assigned a unique machine ID.

2. The [error-log-logger](https://apisix.apache.org/docs/apisix/plugins/error-log-logger/) plugin supports reporting error logs to skywalking, adding to the observability of APISIX. This adds to the observability of APISIX.

## Download

Download Apache APISIX 2.9

- Source code: please visit [download page](https://apisix.apache.org/downloads/)
- Binary installation package: please visit [Installation Guide](https://apisix.apache.org/docs/apisix/how-to-build/)

repository: KishaniKandasamy/apisix-website

repo_name: KishaniKandasamy/apisix-website


text:
# Curse-NFT
Curse NFT

Add a file secrets.json with the network information:

``{
    "alchemyApiKey":"https://rinkeby.infura.io/v3/xxxxxx",
    "mnemonic": ""
}``

```npm install```

To deploy in rinkeby:
```npm run deploy```

repository: mataide/Chainlink-Upgradeable

repo_name: mataide/Chainlink-Upgradeable


text:
## NCPolyInterface {#PackageNCPolyInterface}

The package `NCPolyInterface` provides a basic interface between
[`NCPoly`](#PackageNCPoly) and `NCAlgebra`.

> Note that to take full advantage of the speed-up possible with
> `NCPoly` one should not use these functions. It is always faster to
> convert to and manipulate `NCPoly` expressions directly!

Members are:

* [NCToNCPoly](#NCToNCPoly)
* [NCPolyToNC](#NCPolyToNC)
* [NCMonomialOrderQ](#NCMonomialOrderQ)
* [NCMonomialOrder](#NCMonomialOrder)
* [NCRationalToNCPoly](#NCRationalToNCPoly)
* [NCRuleToPoly](#NCRuleToPoly)
* [NCToRule](#NCToRule)
* [NCReduce](#NCReduce)
* [NCReduceRepeated](#NCReduceRepeated)
* [NCMonomialList](#NCMonomialList)
* [NCCoefficientRules](#NCCoefficientRules)
* [NCCoefficientList](#NCCoefficientList)
* [NCCoefficientQ](#NCCoefficientQ)
* [NCMonomialQ](#NCMonomialQ)
* [NCPolynomialQ](#NCPolynomialQ)

### NCToNCPoly {#NCToNCPoly}

`NCToNCPoly[expr, var]` constructs a noncommutative polynomial object in
variables `var` from the nc expression `expr`.

For example

    NCToNCPoly[x**y - 2 y**z, {x, y, z}]

constructs an object associated with the noncommutative polynomial $x
y - 2 y z$ in variables `x`, `y` and `z`. The internal representation is so
that the terms are sorted according to a degree-lexicographic order in
`vars`. In the above example, $x < y < z$.

### NCPolyToNC {#NCPolyToNC}

`NCPolyToNC[poly, vars]` constructs an nc expression from the
noncommutative polynomial object `poly` in variables `vars`. Monomials are
specified in terms of the symbols in the list `var`.

For example

    poly = NCToNCPoly[x**y - 2 y**z, {x, y, z}];
	expr = NCPolyToNC[poly, {x, y, z}];

returns

	expr = x**y - 2 y**z

See also:
[NCPolyToNC](#NCPolyToNC),
[NCPoly](#NCPoly).

### NCMonomialOrderQ {#NCMonomialOrderQ}

`NCMonomialOrderQ[list]` returns `True` if the expressions in `list`
represents a valid monomial ordering.

`NCMonomialOrderQ` is used by [NCMonomialOrder](#NCMonomialOrder) to
decided whether a proposed ordering is valid or not. However,
`NCMonomialOrder` is much more forgiving when it comes to the format
of the order.

See also:
[NCMonomialOrder](#NCMonomialOrder),
[NCRationalToNCPoly](#NCRationalToNCPoly).

### NCMonomialOrder {#NCMonomialOrder}

`NCMonomialOrder[var1, var2, ...]` returns an array representing a
monomial order.

For example

	NCMonomialOrder[a,b,c]

returns
```output
{{a},{b},{c}}
```
corresponding to the lex order $a \ll b \ll c$.

If one uses a list of variables rather than a single variable as one
of the arguments, then multigraded lex order is used. For example

	NCMonomialOrder[{a,b,c}]

returns
```output
{{a,b,c}}
```
corresponding to the graded lex order $a < b < c$.

Another example:

	NCMonomialOrder[{{a, b}, {c}}]

or

	NCMonomialOrder[{a, b}, c]

both return
```output
{{a,b},{c}}
```
corresponding to the multigraded lex order $a < b \ll c$.

See also:
[NCMonomialOrderQ](#NCMonomialOrderQ),
[NCRationalToNCPoly](#NCRationalToNCPoly),
[SetMonomialOrder](#SetMonomialOrder).

### NCRationalToNCPoly {#NCRationalToNCPoly}

`NCRationalToNCPoly[expr, vars]` generates a representation of the
noncommutative rational expression or list of rational expressions
`expr` in `vars` which has commutative coefficients.

`NCRationalToNCPoly[expr, vars]` generates one or more `NCPoly`s in
which `vars` is used to set a monomial ordering as per
[NCMonomialOrder](#NCMonomialOrder).

`NCRationalToNCPolynomial` creates one variable for each `inv`
expression in `vars` appearing in the rational expression `expr`. It
also created additional relations to encode the inverse. It also
creates additional variables to represent `tp` and `aj`.

It returns a list of four elements:

- the first element is the original expression and any additional
  expressions as `NCPoly`s;
- the second element is the list of variables representing the current
  ordering, including any additional variables created to replace
  `inv`s, `tp`s, and `aj`s;
- the third element is a list of rules that can be used to recover the
  original rational expression;
- the fourth element is a list of labels corresponding to the
  variables in the second element.

For example:

    exp = a+tp[a]-inv[a];
	order = NCMonomialOrder[a,b];
    {rels,vars,rules,labels} = NCRationalToNCPoly[exp, order]

returns

    rels = {
	  NCPoly[{2,1,1},<|{0,0,1,0} -> 1,{0,0,1,1} -> 1,{1,0,0,3} -> -1|>],
	  NCPoly[{2,1,1},<|{0,0,0,0} -> -1,{1,0,1,12} -> 1|>],
	  NCPoly[{2,1,1},<|{0,0,0,0} -> -1,{1,0,1,3} -> 1|>]
    }
	vars = {{a,tp51},{b},{rat50}},
	rules = {rat50 -> inv[a],tp51 -> tp[a]},
	labels = {{a,tp[a]},{b},{inv[a]}}

The variable `tp51` was created to represent `tp[a]` and `rat50` was
created to represent `inv[a]`. The additional relations in `rels`
correspond to `a**rat50 - 1` and `rat50**a - 1`, which encode the
rational relation `rat50 - inv[a]`.

`NCRationalToPoly` also handles rational expressions, not only
rational variables. For example:

    expr = a ** inv[1 - a] ** a;
    order = NCMonomialOrder[a, inv[1 - a]];
    {rels, vars, rules, labels} = NCRationalToNCPoly[expr, order]

returns

	rels = {
	  NCPoly[{1,1},<|{1,2,2} -> 1|>],
	  NCPoly[{1,1},<|{0,0,0} -> -1,{1,0,1} -> 1,{1,1,2} -> -1|>],
	  NCPoly[{1,1},<|{0,0,0} -> -1,{1,0,1} -> 1,{1,1,1} -> -1|>]
    }
	vars = {{a},{rat54}}
	rules = {rat54 -> inv[1 - a]},
	labels = {{a},{inv[1 - a]}}

Note how `rat54` encodes the rational expression `inv[1-a]`.

See also:
[NCMonomialOrder](#NCMonomialOrder),
[NCMonomialOrderQ](#NCMonomialOrderQ),
[NCPolyToNC](#NCPolyToNC),
[NCPoly](#NCPoly),
[NCRationalToNCPolynomial](#NCRationalToNCPolynomial).

### NCRuleToPoly {#NCRuleToPoly}

`NCRuleToPoly[a -> b]` converts the rule `a -> b` into the relation `a - b`.

For instance:

    NCRuleToPoly[x**y**y -> x**y - 1]

returns

    x**y**y - x**y + 1

### NCToRule {#NCToRule}

`NCToRule[exp, vars]` converts the NC polynomial `exp` into a rule `a
-> b` in which `a` is the leading monomial according to the ordering
implied by `vars`.

For instance:

    NCToRule[x**y**y - x**y + 1, {x,y}]

returns

    x**y**y -> x**y - 1

NOTE: This command is not efficient. If you need to sort polynomials
you should consider using NCPoly directly.

See also:
[NCToNCPoly](#NCToNCPoly)

### NCReduce {#NCReduce}

`NCReduce[polys, rules, vars, options]` reduces the list of
polynomials in `polys` by the list of polynomials in `rules` in the
variables `vars`. The substitutions implied by `rules` are applied
repeatedly to the polynomials in the `polys` until no further
reduction occurs.

Note that the exact meaning of rules depends on the polynomial
ordering implied by the `vars`. For example, if

    polys = x^3 + x ** y
    rules = x^2 - x ** y

then

    NCReduce[polys, rules, {y, x}]

produces
```output
x ** y + x ** y ** x
```
because `x^2 - x ** y` is interpreted as `x^2 -> x ** y`, while

    NCReduce[polys, rules, {x, y}]

produces
```output
x^2 + x^3
```
because `x^2 - x ** y` is interpreted as `x ** y -> x^2`.

By default, `NCReduce` only reduces the leading monomial in the
current order. Use the optional boolean flag `Complete` to completely
reduce all monomials. For example,

    NCReduce[polys, rules, Complete -> True]
    NCReduce[polys, Complete -> True]

See [NCPolyReduce](#NCPolyReduce) for a complete list of `options`.

`NCReduce[polys, vars, options]` reduces each polynomial in the list
of `NCPoly`s `polys` with respect to the remaining elements of the
list of polyomials `polys`. It traverses the list of polys just
once. Use [NCReduceRepeated](#NCReduceRepeated) to continue applying
`NCReduce` until no further reduction occurs.

`NCReduce` converts `polys` and `rules` to NCPoly polynomials and
apply [NCPolyReduce](#NCPolyReduce).

See also:
[NCReduceRepeated](#NCReduceRepeated), [NCPolyReduce](#NCPolyReduce).

### NCReduceRepeated {#NCReduceRepeated}

`NCReduceRepeated[polys, vars]` applies `NCReduce` successively to the
list of `polys` in variables `vars` until the remainder does not
change.

See also:
[NCReduce](#NCReduce),
[NCPolyReduceRepeated](#NCPolyReduceRepeated).

### NCMonomialList {#NCMonomialList}

`NCMonomialList[poly, vars]` gives the list of all monomials in the
polynomial `poly` in variables `vars`.

For example:

    vars = {x, y}
	expr = B + A y ** x ** y - 2 x
	NCMonomialList[expr, vars]

returns

	{1, x, y ** x ** y}

See also:
[NCCoefficientRules](#NCCoefficientRules),
[NCCoefficientList](#NCCoefficientList),
[NCVariables](#NCVariables).

### NCCoefficientRules {#NCCoefficientRules}

`NCCoefficientRules[poly, vars]` gives a list of rules between all the
monomials polynomial `poly` in variables `vars`.

For example:

    vars = {x, y}
	expr = B + A y ** x ** y - 2 x
	NCCoefficientRules[expr, vars]

returns

	{1 -> B, x -> -2, y ** x ** y -> A}

See also:
[NCMonomialList](#NCMonomialList),
[NCCoefficientRules](#NCCoefficientRules),
[NCVariables](#NCVariables).

### NCCoefficientList {#NCCoefficientList}

`NCCoefficientList[poly, vars]` gives the list of all coefficients in
the polynomial `poly` in variables `vars`.

For example:

    vars = {x, y}
	expr = B + A y ** x ** y - 2 x
	NCCoefficientList[expr, vars]

returns

	{B, -2, A}

See also:
[NCMonomialList](#NCMonomialList),
[NCCoefficientRules](#NCCoefficientRules),
[NCVariables](#NCVariables).

### NCCoefficientQ {#NCCoefficientQ}

`NCCoefficientQ[expr]` returns True if `expr` is a valid polynomial
coefficient.

For example:

	SetCommutative[A]
    NCCoefficientQ[1]
	NCCoefficientQ[A]
	NCCoefficientQ[2 A]

all return `True` and

	SetNonCommutative[x]
	NCCoefficientQ[x]
	NCCoefficientQ[x**x]
	NCCoefficientQ[Exp[x]]

all return `False`.

**IMPORTANT**: `NCCoefficientQ[expr]` does not expand `expr`. This
means that `NCCoefficientQ[2 (A + 1)]` will return `False`.

See also:
[NCMonomialQ](#NCMonomialQ),
[NCPolynomialQ](#NCPolynomialQ)

### NCMonomialQ {#NCMonomialQ}

`NCCoefficientQ[expr]` returns True if `expr` is an nc monomial.

For example:

	SetCommutative[A]
    NCMonomialQ[1]
	NCMonomialQ[x]
	NCMonomialQ[A x ** y]
	NCMonomialQ[2 A x ** y ** x]

all return `True` and

	NCMonomialQ[x + x ** y]

returns `False`.

**IMPORTANT**: `NCMonomialQ[expr]` does not expand `expr`. This
means that `NCMonomialQ[2 (A + 1) x**x]` will return `False`.

See also:
[NCCoefficientQ](#NCCoefficientQ),
[NCPolynomialQ](#NCPolynomialQ)

### NCPolynomialQ {#NCPolynomialQ}

`NCPolynomialQ[expr]` returns True if `expr` is an nc polynomial with
commutative coefficients.

For example:

	NCPolynomialQ[A x ** y]

all return `True` and

	NCMonomialQ[x + x ** y]

returns `False`.

**IMPORTANT**: `NCPolynomialQ[expr]` does expand `expr`. This
means that `NCPolynomialQ[(x + y)^3]` will return `True`.

See also:
[NCCoefficientQ](#NCCoefficientQ),
[NCMonomialQ](#NCMonomialQ)

repository: NCAlgebra/NC

gha_language: Mercury

repo_name: NCAlgebra/NC


text:
# [CodeShip](https://codeship.com)

* Build automation based on Docker is little bit harder to implement comparing to the traditional one.
* If you think it is not affordable, just use your own machine instead of CodeShip service. All you need is [Jet](https://codeship.com/documentation/docker/installation/). With this build tool, you can set up your own Docker-based build system.

repository: andromedarabbit/awesome-startup-tools

gha_language: CSS

repo_name: andromedarabbit/awesome-startup-tools


text:
# Pangram

This repository is intended as a teaching resource to teach the [Jest](https://facebook.github.io/jest/) JavaScript testing framework.

## Problem Description

Determine if a sentence is a pangram. A pangram (Greek: παν γράμμα, pan gramma,
"every letter") is a sentence using every letter of the alphabet at least once.
The best known English pangram is:
> The quick brown fox jumps over the lazy dog.

The alphabet used consists of ASCII letters `a` to `z`, inclusive, and is case
insensitive. Input will not contain non-ASCII symbols.

## Setup

From the project directory, install the necessary dependency (jest)

```bash
$ npm install
```

## Running the test suite

Run the test suite from the exercise directory with:

```bash
npm test
```

Most of the tests are stubbed out and incomplete.  In the course of the exercise complete the tests.

## Source

This was adapted from the Exercism JavaScript exercise.

- Wikipedia [https://en.wikipedia.org/wiki/Pangram](https://en.wikipedia.org/wiki/Pangram)
- Exercism
[http://exercism.io/exercises/javascript/pangram/readme](http://exercism.io/exercises/javascript/pangram/readme)

repository: CheezItMan/pangram

repo_name: CheezItMan/pangram


text:
Project: /_project.yaml
Book: /_book.yaml

# Converting CocoaPods Dependencies

CocoaPods is a third-party dependency management system for Apple application
development.

[PodToBUILD](https://github.com/pinterest/PodToBUILD){: .external} provides a
`repository_rule` to automatically generate [CocoaPods](https://cocoapods.org/)
Bazel packages that are compatible with [Tulsi](https://tulsi.bazel.build/).

repository: benjaminp/bazel

repo_name: benjaminp/bazel


text:
## Storybook how to

### 0. demo
[storybook demo](https://5f7d1f04988db70022c94c9a-bxsgusmnlc.chromatic.com/)

### Step 1. create react app with [create-react-app](https://create-react-app.dev/docs/adding-typescript/)

```shell
npx create-react-app your-app-name

# or if, typescript.

npx create-react-app your-app-name --template typescript
```

### Step 2. [add storybook](https://storybook.js.org/docs/react/get-started/install)

init storybook with `sb init` on existing project.

```shell
npx sb init
```

> by running above command, storybook will create new directory called `.storybook` with boilerplate components.

then, run it for testing.

```shell
yarn run storybook
```

your storybook will be available on http://localhost:6006/

Step 3. add example component.

### Step 4. run it, publish it.

publising on chromatic.

* signup / signin to chromatic
* create new project
* `yarn add --dev chromatic` to your react app
* `yarn chromatic --project-token=pXXXXXX` which XXXXX should be your own token from chromatic

```
⚠ No 'chromatic' script found in your package.json
Would you like me to add it for you? [y/N] y

✔ Added script 'chromatic' to package.json
You can now run it here or in CI with 'npm run chromatic' or 'yarn chromatic'.

ℹ Your project token was added to the script via the --project-token flag.
If you're running Chromatic via continuous integration, we recommend setting
the CHROMATIC_PROJECT_TOKEN environment variable in your CI environment.
You can then remove the --project-token from your package.json script.

✨  Done in 80.94s.
```

> after this is complete, remove token if possible from `"chromatic": "npx chromatic --project-token pXXXXX"`

your console screen from cromatic.com will be updated as so.

![](./doc/chromatic-steps-publishing-complete.png)

### Step 5 re-run, view diff, collaborate, accept changes

you can re-run the `yarn chromatic --project-token=pXXXXXX` command, it will re publish with diff detection.

supports text style, size, color, and more..

![](./doc/chromatic-steps-publishing-updated-preview.png)

## Available Scripts

> This project was bootstrapped with [Create React App](https://github.com/facebook/create-react-app).

In the project directory, you can run:

### `yarn start`

Runs the app in the development mode.

Open [http://localhost:3000](http://localhost:3000) to view it in the browser.

The page will reload if you make edits.

You will also see any lint errors in the console.

## Learn More

You can learn more in the [Create React App documentation](https://facebook.github.io/create-react-app/docs/getting-started).

To learn React, check out the [React documentation](https://reactjs.org/).

repository: softmarshmallow/fontend-patterns

repo_name: softmarshmallow/fontend-patterns


text:
---
---

# Changing Versions

The point of a version control system such as Git is that you can move
between different versions of a file (or, really, of a working directory).
This means that you can make changes to files while safe in the knowledge
that the old versions of the file are still safe. This can save you from
having to save multiple versions of a file, e.g. `script.py`, `script_v01.py`,
`script_v02.py` etc. etc.

To see all of the available versions of your working directory, type
the command

```
git log
```

You should see output that is similar (but definitely not identical)
to this

```
commit a8b9f7402708d8830e30a510aa55bc5bd20e0b7b
Author: Christopher Woods<EMAIL_ADDRESS>Date:   Wed Oct 28 15:49:24 2015 +0000

    Added some text to something.MD to see if this was found by Git

commit 9253499e0caa7c196cf7a9737de93f3c67c2e2e8
Author: Christopher Woods<EMAIL_ADDRESS>Date:   Wed Oct 28 15:40:02 2015 +0000

    Fixing a typo in README.MD. Cats do not go woof.

commit facfd1c1ffebe8e9a5b8fc4de284cdff112a1e39
Author: Christopher Woods<EMAIL_ADDRESS>Date:   Wed Oct 28 15:38:26 2015 +0000

    Added in another file

commit 63d4556a8c9dde08960440f49cf3fbbaf2e65bed
Author: Christopher Woods<EMAIL_ADDRESS>Date:   Wed Oct 28 15:11:42 2015 +0000

    Added the file README.MD so that we have an initial file to
    play with in Git
```

Each commit is listed, one after another, starting from the latest
commit and moving back to the first commit. Each commit represents
a different version of the working directory, and is given its
own unique ID, e.g. `a8b9f7402708d8830e30a510aa55bc5bd20e0b7b`.

Each commit is also tagged with the name and email address of the
person who committed, together with the commit message. Hopefully
you can now see why this information needed to be given to Git.

By default, `git log` will show information about all commits. To limit
the output to only the last N commits, use the `-n` option. For example,
to print out the log of the last 3 commits, type

```
git log -n 3
```

The log also records the date and time of each commit, and indeed,
each commit represents the working directory at a different point
in time. You can "move" your working directory through time by
"checking out" different versions. To do this, you will need to
use the unique ID of the commit you want to change to, and you will
need to use the `git checkout ID`. where `ID` is the ID of the version
you want to change to.

Now, change back to the first version of your working directory. In my
case, this is version `63d4556a8c9dde08960440f49cf3fbbaf2e65bed`
(the ID of the last commit printed out by `git log`). For me, I do
this by typing

```
git checkout 63d4556a8c9dde08960440f49cf3fbbaf2e65bed
```

You will have to use the ID number of your first version.

You should see Git output something similar to this;

```
Note: checking out '63d4556a8c9dde08960440f49cf3fbbaf2e65bed'.

You are in 'detached HEAD' state. You can look around, make experimental
changes and commit them, and you can discard any commits you make in this
state without impacting any branches by performing another checkout.

If you want to create a new branch to retain commits you create, you may
do so (now or later) by using -b with the checkout command again. Example:

  git checkout -b new_branch_name

HEAD is now at 63d4556... Added the file README.MD so that we have an initial file to play with in Git
```

This confirms that Git has now changed the working directory to match version
`63d4556a8c9dde08960440f49cf3fbbaf2e65bed`. It also outputs some useful information
that we will come back to later...

Type `ls`. You should see now that there is only the file `README.MD` in your
working directory. Take a look at `README.MD` using your text editor. You should
see that this is the original version of the file, in which the cat goes woof.

To return back to the newest version of the working directory, type

```
git checkout master
```

You should get output similar to

```
Previous HEAD position was 63d4556... Added the file README.MD so that we have an initial file to play with in Git
Switched to branch 'master'
```

Now, typing `ls` should reveal that you have both `README.MD` and `something.MD`. If
you take a look at `README.MD`, you should see that this is the fixed version of the
file, in which the cat goes mieow.

Note that you should not edit files in an old version of the working directory.
At the moment, you should treat this as a read-only view of past versions of files.

You can retrieve an old version of a file and pull it into the new version of the
working directory. To do this, use `git checkout` on the file that you want to restore.
For example, if we want to revert back to the original version of `README.MD` (in
which the cat goes woof), then use;

```
git checkout 63d4556a8c9dde08960440f49cf3fbbaf2e65bed README.MD
```

where the ID number is the one from your `git log` output. Type `git status` and
you should see something like

```
# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#	modified:   README.MD
#
```

This shows that `README.MD` has been changed. Take a look at the file in
your text editor. You should see that you have restored the old version
of the file, where the cat goes woof.

If you want to keep this old version, then use `git commit -a` to save
this change. However, you can revert this change using the command

```
git checkout master README.MD
```

This command tells Git to discard any changes made to `README.MD` and
to revert that file back to what it is like in the last committed version
of the working directory. Note here that `master` is a special (global)
Git version, which refers to the latest commit of the working directory.

If you now run `git status` you should see that the working directory is clean,
and a quick check of `README.MD` in a text editor should show you that
the cat is indeed going mieow again.

***

## Exercise

Use `git checkout ID` to move the working directory to the version before
you changed `something.MD`. Verify that `something.MD` is indeed now the
old version.

Use `git checkout master` to move the working directory back to the latest
commit. Verify that `something.MD` is the new version.

Use `git checkout ID something.MD` to revert `something.MD` to its old
version.

Use `git commit -a` to now commit the old version of `something.MD` to
the latest version of the working directory, thereby replacing the
new version. Make sure you write a good commit message to explain
what you have done.

Use `git status` to double-check that your working directory is now clean.

***

# [Previous](../diffing) [Up](../README) [Next](../branching)


text:
---
layout: post
title: RGB Loop
subtitle: This is my RGB loop project. Not to be confused with RBG!
tags: [rgb, loop]
---

## Overview:
In this program I created a loop that prints the LED colors, red, green, and or blue based on how many times you run the program.

## Tip or Trick:
One tip I would give would be to run consistant programs and impliment fixes accoringly. So, try little different fixes to your established code when you are not sure of the solution to trouble-shoot.

![sampler](https://luciasher.github.io/img/rgbloop.png)


text:
**How would you break a mock into a component heirarchy**

draw boxes around every component (and subcomponent) in the mock and give them all names. If you’re working with a designer, they may have already done this

**What is the single responsibility principle and how does it apply to components**

a component should ideally only do one thing. If it ends up growing, it should be decomposed into smaller subcomponents.

**What are the three questions you can ask to determine if something is state?**
Is it passed in from a parent via props? If so, it probably isn’t state.
Does it remain unchanged over time? If so, it probably isn’t state.
Can you compute it based on any other state or props in your component? If so, it isn’t state

**What does it mean to build a ‘static’ version of your application**

use mock data, and pass those down as props to other components as I build out the app. For example, lets look at a real component I will be building, called "Patients". Ignore the JSON format, it will be in regular JS object notation in the real app.

**How can you identify where state needs to live?**

if my component depends on a data to render and show some results, then this data can be placed in state. State changes, component rerenders and show results depending on the state.

**What does it mean to build a ‘static’ version of your application?**

The easiest way is to build a version that takes your data model and renders the UI but has no interactivity. To build a static version of your app that renders your data model, you’ll want to build components that reuse other components and pass data using props.

## Things I want to know more about

I want to know more about lifecycle


text:
[TOC]

`just in develop!`

# Android permission-check

Android ALog provides :
- ~~Full method count 00~~

Less Runtime :
- minSdkVersion 15
- gradle or maven
- jar [You can Download just like this Path]((https://github.com/MDL-Sinlov/MDL-Android-Repo/raw/master/mvn-repo/mdl/sinlov/android/))

> eclipse just use every repo at version `permission-check-x.x.x-jarLib.jar`

Project Runtime:
- Android Studio 2.2.3
- appcompat-v7:23.4.0
- Gradle 2.14.1
- com.android.tools.build:gradle:2.2.3
- minSdkVersion 15

# Last Version Info

- version 0.0.1
- repo at https://github.com/MDL-Sinlov/MDL-Android-Repo

# Dependency

at root project `build.gradle`

```gradle
repositories {
    maven {
        url 'https://raw.githubusercontent.com/MDL-Sinlov/MDL-Android-Repo/master/mvn-repo/'
    }
    jcenter()
    ...
}
```

in module `build.gradle`

```gradle
dependencies {
    compile 'mdl.sinlov.android:permission-check:0.0.1'
}
```

# Build APK for test

- Do not annotation // OutBuildApk_2.0 in `app/build.gradle` then run

```
./gradlew :app:outTAD
```

out `*.apk` at `app/build/outApk`

# Usage

- CheckPermission

```java
mdlPermissionCheck = MDLPermissionUtils.getInstance();
boolean has_permission = mdlPermissionCheck.checkFromManifest(getApplication(), PermissionGroup.OrdinaryGroup.ACCESS_WIFI_STATE);
```

- requestMultiResult

```java
mdlPermissionCheck = MDLPermissionUtils.getInstance();
HashMap<String, Integer> tryPermission = new HashMap<String, Integer>();
for (int i = 0; i < permissionSet.size(); i++) {
    tryPermission.put(permissionArray[i], i + 1);
}
mdlPermissionCheck.requestMultiResult(this, tryPermission, new PermissionGrant() {
    @Override
    public void onPermissionGranted(int requestCode, String permission) {

  }
});
```

- PermissionFloatWindowUtils

```java
permissionFloatWindowUtils = PermissionFloatWindowUtils.getInstance();
boolean checkResult = permissionFloatWindowUtils.checkCanShowFloatWindow(this);
permissionFloatWindowUtils.grantShowFloatWindowPermission(this);
```

###License

---

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

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

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


text:
# PSHPSoftpaq

PSHPSoftpaq manages HP Softpaqs. I wrote it to help me manage the large number of drivers in my Configuration Manager installation.

## What it does

PSHPSoftpaq can:

  1. Download HP Softpaqs and CVA files from HP's software depot.
  2. Extract one or more HP Softpaqs.
  3. Read CVA files to determine OS and platform support.
  4. Import Softpaq drivers into Microsoft Configuration Manager.

In the future, I would like to add the ability to download Softpaqs for a particular platform. The HP Softpaq Download Manager does this, but I find the GUI cumbersome and unfriendly to scripting.

## Examples

Download HP Softpaq SP81653 (The Intel I219 network adapter for the EliteDesk 800 G3.)

```PowerShell
Get-HPSoftpaq -SoftpaqNumber 81653
```

Extract the downloaded Softpaq.

```PowerShell
Expand-HPSoftpaq -FilePath sp81653.exe -Destination \\localhost\SMS_XXX\OSD\Lib\Drivers\sp81653
```

Import the Softpaq into Configuration Manager. Note: This requires the CVA file to be present in the folder.

```PowerShell
Import-Module ConfigurationManager
cd XXX:\
Import-HPSoftpaq -FolderPath \\localhost\SMS_XXX\OSD\Lib\Drivers\sp81653
```

## Installation instructions

  1. Clone the repository to a temporary folder.
  2. Copy the PSHPSoftpaq folder to your PSModulePath.

repository: gfeindel/PSHPSoftpaq

repo_name: gfeindel/PSHPSoftpaq


text:
---
title: Events
layout: default
group: events
---

# **DeepMI FastSurfer / FreeSurfer course**

## Overview

The DeepMI lab is happy to announce a two-day, hands-on, introductory **FastSurfer/FreeSurfer course** focussing on the analysis of structural brain MRI data. The course consists of lectures, demonstrations, and practical exercises and will cover a range of topics, such as:

- Advanced deep-learning for image segmentation
- Organization, processing, and inspection (QC) of brain MRI data
- Evaluation and interpretation of results
- General linear models for statistical analysis
- Future directions

The goal of the course is to equip participants with working knowledge about fundamental concepts in structural neuroimaging analysis, and enable them to conduct analyses of structural imaging data using the [FastSurfer](https://deep-mi.org/research/fastsurfer) and [FreeSurfer](https://surfer.nmr.mgh.harvard.edu) software packages.

## Dates

The course will be held on **September 28 and 29** (Thursday and Friday) **between 9:00 am and 4:30 pm**.

## Places

The course takes place at the **German Center for Neurodegenerative Diseases (DZNE)**, Venusberg Campus, Bonn.

Room: **B.1.119/120**. Non-DZNE participants will be picked-up at 9 am each day at the reception in the DZNE main building.

## Preliminary Schedule

_Thursday, September 28:_

Time	Topic

09:15 - 09:30	Welcome

09:30 - 10:30	FastSurfer / FreeSurfer overview

10:30 - 10:45	Break

10:45 - 12:30	Analyzing individual cases 1: volumes

12:30 - 13:30	Lunch break

13:30 - 14:30	Analyzing individual cases 2: surfaces (part 1)

14:30 - 14:45	Break

14:45 - 15:45	Analyzing individual cases 2: surfaces (part 2)

15:45 - 16:30	Questions and answers

_Friday, September 29:_

Time	Topic

09:15 - 10:30	Group analysis (part 1)

10:30 - 10:45	Break

10:45 - 12:30	Group analysis (part 2)

12:30 - 13:30	Lunch break

13:30 - 14:30	QC, troubleshooting, edits, and limitations

14:30 - 14:45	Break

14:45 - 15:45	Add-ons and outlook

15:45 - 16:30	Questions and answers

All sessions will contain lectures and demos as well as practical and interactive parts.

## Registration

The intended audience for this course is the DZNE and UKB neuroimaging community, as well as external guests.

There is a maximum capacity of **20 participants** and no course fee.

Registration is now closed.

## Requirements

Participants should have initial experience in working with MRI data.

During the course, participants will be provided with workstations, software, and materials for the lectures and practical exercises.

We can neither provide support for personal devices nor individual datasets.

## Contact

Deep Medical Imaging Lab

German Center for Neurodegenerative Diseases (DZNE)

Venusberg Campus 1/99

Bonn, Germany

martin.reuter(at)dzne.de

kersten.diers(at)dzne.de

gha_language: HTML


text:
# Parastrombidinopsis Kim, Jeong, Strüder-Kypke, Lynn, Kim, Kim & Lee, 2005 GENUS

#### Status
ACCEPTED

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

#### Published in
Journal of Eukaryotic Microbiology 52: -. [514-522]

#### Original name
null

### Remarks
null


text:
# R-Conference-Explorer
This project has the potential to become a central tool for exploring past and future events globally and regionally. <br>
See the sample dashboard here: https://meetdarkpow.github.io/RConf-sample-dashboard/rconf_sample_dashboard.html

repository: MeetDarkPow/R-Conference-Explorer

repo_name: MeetDarkPow/R-Conference-Explorer


text:
# AutoScreenshot

Built to capture screenshots of a list of webpages in an automated fashion.

## Installation

Add this line to your application's Gemfile:

    gem 'auto_screenshot'

And then run:

    bundle

Or install it yourself as:

    gem install auto_screenshot

## Options

### URLs

An array of valid URLs. Pretty simple.

### Folder

`folder` is where the screenshots will be saved.  The default location is the `screenshots` folder based on where the program is run. But, the example below passes a specific folder path to save screenshots at.

    client = AutoScreenshot::Screenshot.new(:folder => '/path/to/folder/')

### Action Map

`action_map` is a ruby hash. each key of the hash is a full URL string
and each key is a symbol. The symbol corresponds to a name of a method like `wait`. Here is an example:

    action_map = {
      "http://example.com/page" => :wait
    }

And a custom method could look like:

    def wait
      sleep 10 # To allow you to login or something
    end

## Usage

AutoScreenshot saves screenshots of webpages as .png files in a folder.  Create a Screenshot client and specify an array of URLs to capture.

#### Create a Client. Then set options.

    client = AutoScreenshot::Screenshot.new #=> get a Screenshot object
    client.urls = ["http://google.com, http://github.com"]
    client.folder = "/custom/folder/path"
    client.action_map = {
      "http://example.com/do-something-custom-at-this-url" => :custom_method
    }

or

#### Create a Client with options.

    client = AutoScreenshot::Screenshot.new(:urls => [], :folder => "/custom/folder/path", :action_map => {@url_string => :custom_method})

## Contributing

1. Say [hi](https://twitter.com/randw) and let me know you're using aut
1. Fork it
1. Create your feature branch (`git checkout -b my-new-feature`)
1. Commit your changes (`git commit -am 'Add some feature'`)
1. Push to the branch (`git push origin my-new-feature`)
1. Create new Pull Request

### During Development

Run this from the `auto_screenshot/` directory.

    irb
    load 'lib/auto_screenshot.rb'

And, to build the .gem:

    gem build auto_screenshot.gemspec


text:
# Some useful GL3 references

If you are a beginner to GL3, try first understanding the graphic pipeline that GL3 constructs. Geometry is made of vertices which are processed by vertex shaders, or generated by geometry shaders, which then are turned into fragments (pixels) which are draw by vertex shaders from static resources. Such static resources / inputs may be textures, global variables (uniforms.) Finally those fragments are combined into pixels on the screen.

GL3 requires the construction of objects to represent each of these concepts, which are all identified by a unique integer identifier.

- http://docs.gl — API reference
- https://www.opengl.org/wiki/Common_Mistakes — Practical experience
- http://www.opengl.org/sdk/docs/reference_card/opengl32-quick-reference-card.pdf — gl3 reference card

# Graphics Pipeline

Fabien Giesen has written a series of articles going in depth about the graphics pipeline:

- http://fgiesen.wordpress.com/2011/07/09/a-trip-through-the-graphics-pipeline-2011-index/

gha_language: C


text:
/*
Title: September 9, 2020
Sort: -1
*/

### Magical Fuckery Afoot

[Pavel Kilkaelan](%base_url%/players/pavel-kilkaelan) and [Presdove Firhael](%base_url%/players/presdove-firhael) are heading to local village for supplies. Encounter enraged bear and kill it. Evidence of magical burns on it. More arcane fire and burned rats on the way to town.

### Pest Control for Glowkindle

Meet [Gorth Clamly](%base_url%/players/gorth-clamly) and [Melmond Thurgus](%base_url%/players/melmond-thurgus) outside of town. They have a job waiting for them at tavern, all agree to join up. Tavern owner [Glowkindle](%base_url%/people/glowkindle) explains he has pest problem -- huge scary rats in the basement. His employees were hurt trying to exterminate. Willing to pay us to finish the job. Tavern built on old wizard tower?

### Mosaic Puzzle

Floor tiles with idyllic scene. Corpses suggest trap. Poem painted on the wall in gold:

> Dawn breaks with stirring air,
> As sun shines down on new day fair.
>
> Midday blaze bakes earth and grass,
> The farmer waits for heat to pass.
>
> Evening cool brings water, wine,
> Drink and laughter passing time.
>
> Night sees shining, roaring fire,
> as wood and coals burn on the pyre.

Solved by stepping only on the images mentioned: _sun_, _grass_, _water_, _fire_.

### Giant Fire Spider

Massive flaming spider attacked and pins [Melmond](%base_url%/players/melmond-thurgus).  Turns out the animals were drinking leftover wizard potions and getting all roided out.

### Reward

[Glowkindle](%base_url%/people/glowkindle) gives the party 50GP each.

repository: rektdeckard/fellowship-of-the-spruce

repo_name: rektdeckard/fellowship-of-the-spruce


text:
anyTide_Cwrapper
================

Do harmonic reconstructions using a python wrapper on a C-code engine
16 July 2018 -<EMAIL_ADDRESS>
NOCtidepred.py
==============

Conversion of NOCtidepred.m (from<EMAIL_ADDRESS>into python.
Demonstration for 1D port and 2D model tidal reconstruction.
16 July 2018 -<EMAIL_ADDRESS>
Oban_demo.py
============

Demonstration for Oban tides (tested in python3.8 18 Oct 2021):
$python Oban_demo.py

repository: NOC-MSM/anyTide

repo_name: NOC-MSM/anyTide


text:
[![Youtube-Page-Generator](https://github.com/SSanjeevi/YoutubeChannelWebsite/actions/workflows/main.yml/badge.svg)](https://github.com/SSanjeevi/YoutubeChannelWebsite/actions/workflows/main.yml)

# Videos-By-Sanjeevi
Youtube Channel Website

## How to Reuse this Template which creates a personal website hosted in Github Pages using Jekyll and Github Actions for free!

1. Fork this repo: [Fork this on github](https://github.com/SSanjeevi/YoutubeChannelWebsite/fork)

2. Create Secret in Github repo and add secret named: "GOOGLEAPIKEY" with value of Google console api id.
3. Update your channel name in the file workflow - [File line : 18](https://github.com/SSanjeevi/YoutubeChannelWebsite/blob/gh-pages/.github/workflows/main.yml)
     > python ./youtubeChannelVideosFinder.py -k ${{ secrets.GOOGLEAPIKEY }} -c 'your-channel-name-here' --output-file-path index.md

3. Enable the repo as github pages, your website is ready.

Reference:

https://github.com/dsebastien/youtubeChannelVideosFinder

https://github.com/nathancy/jekyll-embed-video

repository: SSanjeevi/timeline-jekyll-theme

repo_name: SSanjeevi/timeline-jekyll-theme


text:
# this is a template

> A project template with mpvue+iView

# Install it
### First: you must insure you alredy install npm\vue enviroment

### clone mpvue Codes
``` bash
## `getStart` is your project name
git clone https://github.com/gitcyc/mpvue getStart
```

### clone iView Codes
``` bash
git clone https://github.com/TalkingData/iview-weapp
# [cmd] move the core codes to your project
move iview-weapp/dist getStart/dist/static/iview
# [cmd] delete the others file
rmdir /s/q iview-weapp
```

### install dependencies
``` bash
cd getStart
npm install
```

### Compiling and work
``` bash
npm run dev
```

### Other command
``` bash

# build for production with minification
npm run build

# build for production and view the bundle analyzer report
npm run build --report
```

### notice
##### if you want to modify the config of compile option, try to modify these two files:package.json、config/index.js

### MORE

Guide (http://vuejs-templates.github.io/webpack/)

Docs (http://vuejs.github.io/vue-loader)


text:
---
title: E2E Testing
---

End-to-end tests are located in the `src/e2e` directory.

## Build and Run E2E Tests

### Watch mode (for development)

```
npm run e2e
```

This command builds and executes the e2e tests. If you modify a file and save it, the code is rebuilt and the tests are run again. This is particularly useful in development: you do not need to re-run the command every time you make code changes.

The process runs forever until you stop it.

### Simple mode (for CI and Git hooks)

If you need to build and run the tests only once, you can use these two commands:

```sh
npm run build:e2e # Build the e2e tests code (compile the typescript files and copy the templates)
npm run start:e2e # Execute the e2e tests from the built files
```

These commands are particularly useful when you want to integrate your tests into a CI pipeline or a Git hook.

## The `SuperTest` library

You can use [the SuperTest library](https://github.com/visionmedia/supertest) to write your e2e tests. It is installed by default.

*Simple example*
```typescript
// 3p
import { createApp } from '@foal/core';
import * as request from 'supertest';
import { getConnection } from 'typeorm';

// App
import { AppController } from '../app/app.controller';

describe('The server', () => {

  let app;

  before(async () => {
    app = await createApp(AppController);
  });

  after(() => getConnection().close());

  it('should return a 200 status on GET / requests.', () => {
    return request(app)
      .get('/')
      .expect(200);
  });

});

```

*Advanced example*
```typescript
// std
// The `assert` module provides a simple set of assertion tests.
import { ok } from 'assert';

// 3p
import { createApp } from '@foal/core';
import * as request from 'supertest';
import { getConnection } from 'typeorm';

// App
import { AppController } from '../app/app.controller';
import { User } from '../app/entities';

// Define a group of tests.
describe('The server', () => {

  let app: any;

  // Create the application and the connection to the database before running all the tests.
  before(async () => {
    app = await createApp(AppController);
  });

  // Close the database connection after running all the tests whether they succeed or failed.
  after(() => getConnection().close());

  // Define a nested group of tests.
  describe('on GET /api/todos requests', () => {

    it('should return a 401 status if the user did not signed in.', () => {
      return request(app)
        .get('/api/todos')
        .expect(401);
    });

    it('should return a 200 status if the user did signed in.', async () => {
      // Create a new user in the empty database.
      const user = new User();
      user.email =<EMAIL_ADDRESS>      await user.setPassword('john_password');
      await getConnection().manager.save(user);

      // Log the user in.
      let cookie = '';
      await request(app)
        .post('/auth/login')
        // Set the body of the request
        .send({ email<EMAIL_ADDRESS>password: 'john_password' })
        // The response should have the status 302 (redirection)
        .expect(302)
        .then(data => {
          // The response should set the authentication cookie for the next requests.
          ok(Array.isArray(data.header['set-cookie']));
          // Save the cookie to be able to use it in further requests.
          cookie = data.header['set-cookie'][0];
        });

      // Test the /api/todos endpoint when the user has logged in.
      return request(app)
        .get('/api/todos')
        // Send the authentication cookie.
        .set('Cookie', cookie)
        .expect(200);
    });

  });

});
```

repository: FoalTS/foal

repo_name: FoalTS/foal


text:
---
title: 'Serverless Framework - Auth0 Webtasks Guide - Quick Start'
menuText: 'Quick Start'
menuOrder: 2
description: 'Get started with Auth0 Webtasks in 5 minutes or less'
layout: Doc
gitLink: /docs/providers/webtasks/guide/quick-start.md
---

# Auth0 Webtasks - Quick Start

This guide is designed to help you get started as quick as possible.

## 1. Create a new service

1. Create a new service with the [`webtasks-nodejs`](https://github.com/serverless/serverless/tree/master/lib/plugins/create/templates/webtasks-nodejs) template

```bash
serverless create --template webtasks-nodejs --path my-service
```

2. Install the dependencies

```bash
cd my-service
npm install
```

## 2. Set up the credentials

Run the [config crendentials command](../../cli-reference/config-credentials) to create a local profile. You will be asked for a phone number or email. You'll immediately receive a verification code. Enter the verification code and your profile will be entirely setup and ready to use.

```bash
serverless config credentials --provider webtasks
```

## 4. Deploy

Run the [deploy command](../../cli-reference/deploy)

```bash
serverless deploy
```

## 5. Invoke

Run the [invoke command](../../cli-reference/invoke)

```bash
serverless invoke --function main
```

repository: Codebrahma/serverless-gatsby

repo_name: Codebrahma/serverless-gatsby


text:
---
layout: page
title: About
permalink: /about/
---

This is me...or is it?

This is a place where I collect random thoughts and stories that happen during my working hours.

### The name

The name `traitshifter` is a conglomerate of references to what I do.

A trait is a [Rust thing](https://doc.rust-lang.org/book/ch10-02-traits.html), the language I currently mostly use.
I work for SUSE, with the lovely mascot [geeko](https://en.opensuse.org/User:Geeko), which is a chameleon. Not so much a shapeshifter, as a colorshifter, but you get the idea.
And finally, the idea of this blog is to wear a different persona for each article.


text:
# pass-web

[![NPM version](https://img.shields.io/npm/v/pass-web.svg)](https://www.npmjs.com/package/pass-web)
[![Build Status](https://travis-ci.org/BenoitZugmeyer/pass-web.svg?branch=master)](https://travis-ci.org/BenoitZugmeyer/pass-web)

A web interface for [pass](http://www.passwordstore.org/) (password-store).

## Install

For those lucky enough to run Arch Linux, you should install it [from
AUR](https://aur.archlinux.org/packages/pass-web)

For other, you can install it via npm:

```
$ npm install -g pass-web
```

You will need nodejs 5+ to run it.

## Usage

The executable is called `pass-web`. Use `pass-web --help` to get help.

## HTTPS concerns

You should always use HTTPS to serve this application. Please use the `--cert` and `--key` options
to provide an SSL certificate and key, or use another HTTP server (like nginx) configured to serve
this through an HTTPS-enabled reverse proxy.

## Demo

For a preview of the interface you'll get when using this project, go to
[https://benoitzugmeyer.github.io/pass-web/](https://benoitzugmeyer.github.io/pass-web/)

## Notes

This is currently a read-only interface, and there is no plan to support all the features
of pass. The goal was to have a nice and simple access to the password store from anywhere. But if
you need other features, feel free to ask or contribute.

This project may have some security flaws. Please open an issue if something's fucky.

repository: BenoitZugmeyer/pass-web

repo_name: BenoitZugmeyer/pass-web


text:
### [CVE-2017-5055](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-5055)
![](https://img.shields.io/static/v1?label=Product&message=Google%20Chrome%20prior%20to%2057.0.2987.133%20for%20Linux%20and%20Windows&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=Use%20After%20Free&color=brighgreen)

### Description

A use after free in printing in Google Chrome prior to 57.0.2987.133 for Linux and Windows allowed a remote attacker to perform an out of bounds memory read via a crafted HTML page.

### POC

#### Reference
No PoCs from references.

#### Github
- https://github.com/allpaca/chrome-sbx-db

repository: trickest/cve

repo_name: trickest/cve


text:
### Analysis Notes

#### Three trends based on this dataset:

1. School size and score results can have a negative effect on student performance. The larger the number of students, the lower success in grades.

2. The budget per student and spending levels are negatively correlated with scores.

3. Students from Charter schools perform better than students from District schools. The data shows a significant difference with the overall passing rate among students between Charter and District schools. The largest Charter school has much better scores than the smallest District school. This data only takes into consideration large District and small Charter school size so there is probably a discrepancy with the two types of schools.

**District Summary**

* District's key metrics, including:
  * Total Schools
  * Total Students
  * Total Budget
  * Average Math Score
  * Average Reading Score
  * % Passing Math
  * % Passing Reading
  * Overall Passing Rate (Average of the above two)

**School Summary**

* Overview table summarizing key metrics about each school, including:
  * School Name
  * School Type
  * Total Students
  * Total School Budget
  * Per Student Budget
  * Average Math Score
  * Average Reading Score
  * % Passing Math
  * % Passing Reading
  * Overall Passing Rate (Average of the above two)

**Top Performing Schools (By Passing Rate)**

* Top 5 performing schools based on Overall Passing Rate:
  * School Name
  * School Type
  * Total Students
  * Total School Budget
  * Per Student Budget
  * Average Math Score
  * Average Reading Score
  * % Passing Math
  * % Passing Reading
  * Overall Passing Rate (Average of the above two)

**Top Performing Schools (By Passing Rate)**

* This table highlights the bottom 5 performing schools based on Overall Passing Rate. Includes all of the same metrics as above.

**Math Scores by Grade**

* This table lists the average Math Score for students of each grade level (9th, 10th, 11th, 12th) at each school.

**Reading Scores by Grade**

* This table lists the average Reading Score for students of each grade level (9th, 10th, 11th, 12th) at each school.

**Scores by School Spending**

* This table breaks down school performances based on average Spending Ranges (Per Student). Includes the following:
  * Average Math Score
  * Average Reading Score
  * % Passing Math
  * % Passing Reading
  * Overall Passing Rate (Average of the above two)

**Scores by School Size**

* This table groups schools based on a reasonable approximation of school size (Small, Medium, Large).

**Scores by School Type**

* This table groups schools based on school type (Charter vs. District).

![Education](Images/education.jpg)

Coding Boot Camp (C) 2018. All Rights Reserved.

repository: risatino/academy-of-py

repo_name: risatino/academy-of-py


text:
# Volumio websocket api reference for android kotlin developement

To begin we need an Socket.IO client, if you are not up to implementing it yourself, you can use ready made from nkzawa which is the one that is used in the samples provided here
`implementation 'com.github.nkzawa:socket.io-client:0.6.0'`

  # Connecting
  Connecting to socket is simple, endpoint in the example below is the IP address of volumio as String value
  ```
    volumioSocket = IO.socket("http://$endpoint:3000/")
  ```
  ## Sending information to volumio

```
volumioSocket?.emit("event", payload)
```
`event` is the event we want to trigger on volumio side, ie. seek
`payload` here should be `org.json.JSONObject`
`argument` is what we put into the payload
*take a note of the terms above, those will be used throught the document*

In the code below we emit `seek` event, with argument named `value` which value is `1000`
```
val payload =
    JSONObject().apply {
        put("value", 1000)
}
volumioSocket?.emit("seek", payload)
```

  ## Registering for events triggered by volumio
```
    volumioSocket?.on("event", callback)
```
`event` is the event we want to listen
`callback` is a `Emitter.Listener` from the Socket library, which we can use like
```
val callback = Emitter.Listener { received ->
    //do something with the received information
}
```

 ----
## Playback events
Possible events without arguments are
+ `play`
+ `pause`
+ `stop`
+ `toggle`
+ `prev`
+ `next`

In addition there are few playback events which needs arguments to be passed

#### `setRepeat`

+ `value` : `Boolean`
+ `repeatSingle` : `Boolean`

#### `setRandom`
+ `value` : `Boolean`

#### `seek`
+ `value` : `Long`

Usage `volumioSocket?.emit(event)`
Usage `volumioSocket?.emit(event, payload)`

----
# Volume events
Event is `volume`
Payload is `+` `-` `mute` `unmute` or numerical value in between `0` and `100`

Usage `volumioSocket?.emit(event, payload)`

----

# Queuea
Possible events are
+ `play`
+ `removeQueueItem`
+ `moveQueue`
+ `clearQueue`
+ `addToQueue`
+ `replaceAndPlay`

**Queue commands use ZERO based indexing, first item is 0, second is 1 etc.**

### Play From position
```
val payload = JSONObject().apply {
    put("value", position)
}
volumioSocket?.emit("play", payload)
```
### Remove from position
```
val payload = JSONObject().apply {
    put("value", pos)
}
volumioSocket?.emit("removeQueueItem", payload)
```
### Reorder Queue
```
val payload = JSONObject().apply {
    put("from", trackFrom)
    put("to", to)
}
volumioSocket?.emit("moveQueue", payload)
```
### Clear queue
```
volumioSocket?.emit("clearQueue")
```
### Add Item(s) to queue
`VolumioNavItem` you can see in below examples, is parsed json response we get from volumio websocket when browsing, more on that later
`VolumioNavItem` can be atleast track, playlist or album from various sources such as tidal, qobuz, spotify or "local" files
```
fun add(item: VolumioNavItem) {
    val obj = JSONObject().apply {
        put("uri", item.uri)
        put("title", item.name)
        put("service", item.service)
        put("albumart", item.art)
    }
    volumioSocket?.emit("addToQueue", obj)
}
```
### Replace queue
`VolumioNavItem` can be atleast track, playlist or album from various sources such as tidal, qobuz, spotify or "local" files
```
fun replaceAndPlay(item : VolumioNavItem){
    val json = JSONObject().apply {
        put("uri", item.uri)
        put("title", item.name)
        put("service", item.musicService.toLowerCase())
        put("albumart", item.art)
    }
    volumioSocket?.emit("replaceAndPlay", json)
}
```
----

##WORK IN PROGRESS

repository: Joni-Salminen/docs

repo_name: Joni-Salminen/docs


text:
# viewtools

Viewtools provides "view" objects which can be manipulated with slices without introducing copies.

## SequenceView

```python
>>> import viewtools
>>> view = viewtools.SequenceView([2, 1, 4, 7, 4, 8, 3, 6, 4, 7])
>>> view
SequenceView([2, 1, 4, 7, 4, 8, ...])[0:10:1]
```

The usual [sequence](https://docs.python.org/3/library/collections.abc.html#collections.abc.Sequence) methods works on views:

```python
>>> view[3::2]
SequenceView([2, 1, 4, 7, 4, 8, ...])[3:10:2]
>>> list(view[3::2])
[7, 8, 6, 7]
>>> view[3::2][1]
8
>>> 6 in view[3::2]
True
>>> view[3::2].count(7)
2
>>> view[3::2].index(8)
1
>>> view[3::2].index(3)
ValueError: 3 is not in view
```

Slicing a view doesn't copy the underlying sequence unless requested:

```python
>>> view[3::2][::-1]
SequenceView([2, 1, 4, 7, 4, 8, ...])[9:1:-2]
>>> list(view[3::2][::-1])
[7, 6, 8, 7]
```

## Planning

* `StringView` which supports the usual string methods
* `ZipView`


text:
# Generator for Android Clean Architecture Boilerplate

Android Clean Architecture Boilerplate Generator generates an Android application with basic boilerplate code based on Clean Architecture.

Stack:
- [Kotlin](https://kotlinlang.org/)
- [RxJava](https://github.com/ReactiveX/RxJava) and [RxAndroid](https://github.com/ReactiveX/RxAndroid)
- [Retrofit](http://square.github.io/retrofit/) / [OkHttp](http://square.github.io/okhttp/)
- [Gson](https://github.com/google/gson)
- [Dagger 2](http://google.github.io/dagger/)
- [Timber](https://github.com/JakeWharton/timber)
- [Stetho](http://facebook.github.io/stetho/)

## Installation

Assuming you have pre-installed [node.js](https://nodejs.org/)), perform the following steps:

Install [Yeoman](http://yeoman.io)
```
npm install -g yo
```

Install the generator-android-clean-architecture-boilerplate

```
npm install -g generator-android-clean-architecture-boilerplate
```

Generate your new project as follows:

```
mkdir NewApp
cd NewApp
yo android-clean-architecture-boilerplate
```

You might also check out my [blog](https://medium.com/techtics/android-clean-architecture-boilerplate-code-generator-79a450941ec8) for this generator and a [video](https://www.youtube.com/watch?v=ti0Fwpm1F9Y) on how to install and run it.

### Created & Maintained By
Arundhati Gupta [@arundhatigupta](https://github.com/arundhatigupta)

### Acknowledgements
Thank you Akshat Garg [@akshatnitd](https://github.com/akshatnitd) for the idea and feedback.

Visit [www.arundhatigupta.in](http://www.arundhatigupta.in) for more info.

If you found this project helpful and want to thank me, you might buy me a cup of coffee! :smiley:


text:
^title Functions

When you want to bundle up a reusable chunk of code in Magpie, you'll usually use a [method](multimethods.html). But sometimes you want a chunk of code that you can pass around like a value. For that, you'll use a *function*. Functions are first-class objects that encapsulate an executable expression.

## Creating Functions

Functions are defined using the `fn` keyword followed by the expression that forms the body of the function.

    :::magpie
    fn print("I'm a fn!")

This creates an anonymous function that prints `"I'm a fn!"` when called. The body of a function can be a single expression like above or can be a [block](blocks.html).

    :::magpie
    fn
        print("First!")
        print("Second!")
    end

## Parameters

To make a function that takes an argument, put a [pattern](patterns.html) for it in parentheses after the `fn` keyword.

    :::magpie
    fn(name, age) print("Hi, " + name + ".

Like with methods, any kind of pattern can be used here. Go crazy.

### Implicit Parameters

When programming in a functional style, you often have lots of little functions that just call a method or do some trivial expression. Here's a line of code to pull the even numbers from a collection:

    :::magpie
    val evens = [1, 2, 3, 4, 5] where(fn(n) n % 2 == 0)

To make this a little more terse, Magpie supports *implicit parameters*. The above code can also be written:

    :::magpie
    val evens = [1, 2, 3, 4, 5] where(fn _ % 2 == 0)

Note that the parameter pattern is gone, and `n` in the body has been replaced with `_`.

The rule for implicit parameters is pretty simple. If a function has no parameter pattern, then a pattern will be created for it. Every `_` that appears in the body of the function will be replaced with a unique variable for each occurrence. Then a pattern will be created that defines those variables in the order that they appear.

The "unique variable" and "order that they appear" parts are important here, since you can have multiple implicit parameters. When you do, each `_` becomes its *own* parameter for the function.

    :::magpie
    fn (_ + _) / _

This creates a function with *three* separate implicit parameters. It's equivalent to:

    :::magpie
    fn(a, b, c) (a + b) / c

Implicit parameters can help code be more readable when the function body is small and the parameters are obvious from the surrounding context. But they can also render your code virtually unreadable (like the above example here) otherwise. Like all pointy instruments, wield it with care.

## Calling Functions

Once you have a function, you call it by invoking the `call` method on it. The left-hand argument is the function, and the right-hand argument is the argument passed to the function.

    :::magpie
    var greeter = fn(who) print("Hi, " + who)
    greeter call("Fred") // Hi, Fred

If a function doesn't take an argument, then there won't be a right-hand argument to `call`.

    :::magpie
    var sayHi = fn print("Hi!")
    sayHi call

Like methods, the argument pattern for a function may include tests. If the argument passed to `call` doesn't match the function's pattern, it throws a `NoMethodError`.

    :::magpie
    var expectInt = fn(n is Int) n * 2
    expectInt call(123) // OK
    expectInt call("not int") // Throws NoMethodError.

If you pass too many arguments to a function, the extra ones will be ignored.

    :::magpie
    var takeOne = fn(n) print(n)
    takeOne call("first", "second") // Prints "first".

However, if you pass too *few*, it will throw a `NoMethodError`.

    :::magpie
    var takeTwo = fn(a, b) print(a + b)
    takeOne call("first") // Throws NoMethodError.

## Returning Values

A function automatically returns the value that its body evaluates to. An explicit `return` is not required:

    :::magpie
    var name = fn "Fred"
    print(name call) // Fred

If the body is a block, the result is the last expression in the block:

    :::magpie
    var sayHi = fn
        print("hi")
        "result"
    end
    sayHi call // Prints "hi" then returns "result".

If you want to return before reaching the end of the function body, you can use an explicit `return` expression.

    :::magpie
    var earlyReturn = fn(arg)
        if arg == "no!" then return "bailed"
        print("got here")
        "ok"
    end

This will return `"bailed"` and print nothing if the argument is `"no!"`. With any other argument, it will print `"got here"` and then return `"ok"`.

A `return` expression with no expression following the keyword (in other words, a `return` on its own line) implicitly returns `nothing`.

## Closures

As you would expect, functions are
[closures](http://en.wikipedia.org/wiki/Closure_%28computer_science%29): they
can access variables defined outside of their scope. They will hold onto closed-over variables even after leaving the scope where the function is defined:

    :::magpie
    def makeCounter()
        var i = 0
        fn i = i + 1
    end

Here, the `makeCounter` method returns the function created on its second line. That function references a variable `i` declared outside of the function. Even after the function is returned from `makeCounter`, it is still able to access `i`.

    :::magpie
    var counter = makeCounter()
    print(counter call // Prints "1".
    print(counter call) // Prints "2".
    print(counter call) // Prints "3".

## Callables

The `call` method used to invoke functions is a regular multimethod with a built-in specialization for functions. This means you can define your own "callable" types, and specialize `call` to act on those. With that, you can use your own callable type where a function is expected and it will work seamlessly.

repository: munificent/magpie

gha_language: Python

repo_name: munificent/magpie