text:
# Contributing

If you would like to help, please take a look at the list of
[issues](https://github.com/composer/installers/issues).

## Pull requests

* [Fork and clone](https://help.github.com/articles/fork-a-repo).
* Run the command `php composer.phar install` to install the dependencies.
  This will also install the dev dependencies. See [Composer](https://getcomposer.org/doc/03-cli.md#install).
* Use the command `phpunit` to run the tests. See [PHPUnit](http://phpunit.de).
* Create a branch, commit, push and send us a
  [pull request](https://help.github.com/articles/using-pull-requests).

To ensure a consistent code base, you should make sure the code follows the
coding standards [PSR-1](http://www.php-fig.org/psr/psr-1/) and
[PSR-2](http://www.php-fig.org/psr/psr-2/).

### Create a new Installer

* Create class extends `Composer\Installers\BaseInstaller` with your Installer.
* Create unit tests as a separate class or as part of a `Composer\Installers\Test\InstallerTest`.
* Add information about your Installer in `README.md` in section "Current Supported Package Types".
* Run the tests.

repository: surprisehighway/craft-avataxtaxadjuster

gha_language: PHP

repo_name: surprisehighway/craft-avataxtaxadjuster


text:
# mcannounce

mcannounce is a tool that will announce a minecraft server to the LAN.

Modeled after the python implementation of a similar minecraft server announcement script described at https://void7.net/advertising-linux-minecraft-servers-to-the-lan/,
mcannounce broadcasts one or more server announcements to the local network.

NOTE: This application does not currently run on Windows, as Crystal doesn't support Windows yet. Windows support is coming though, see https://github.com/crystal-lang/crystal/issues/5430.

## Installation

You can either donwload and run a pre-built application binary, or build it yourself.

### Download a pre-built binary
1. Download either the macos or linux binary from github. Windows is currently not supported, as Crystal doesn't support Windows yet. Windows support is coming though, see https://github.com/crystal-lang/crystal/issues/5430.

### Build mcannounce yourself
1. Clone the `mcannounce` repo.
2. `cd mcannounce`
3. `crystal build mcannounce.cr`

## Usage

1. Write a file named `mcannounce.yml` (all lower case) in the same directory as the mcannounce application binary.
2. Run the `mcannounce` binary.
3. When you're done running the application, break out of it by pressing <ctrl+c>.

Example:

```
~ ❯ cat mcannounce.yml
broadcast_ip: <IP_ADDRESS>
broadcast_port: 4445
servers:
  - name: Local Network - Creative
    port: 25565
  - name: Local Network - Survival (easy)
    port: 25566
  - name: Local Network - Survival (standard)
    port: 25567
  - name: Local Network - Survival (hard)
    port: 25568
~ ❯ ./mcannounce
Announcing the following Minecraft servers to LAN:
********************************************************************************
server: Local Network - Creative
port: 25565
********************************************************************************
server: Local Network - Survival (easy)
port: 25566
********************************************************************************
server: Local Network - Survival (standard)
port: 25567
********************************************************************************
server: Local Network - Survival (hard)
port: 25568
^C
```

## Contributing

1. Fork it (<https://github.com/your-github-user/mcannounce/fork>)
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create a new Pull Request

## Contributors

- [David Ellis](https://github.com/davidkellis) - creator and maintainer

license: MIT

repository: davidkellis/mcannounce

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: davidkellis/mcannounce


text:
[![NuGet](https://img.shields.io/nuget/v/imagekit.svg)]()
# DotNET ImageKit.io integration
This is the ImageKit.io integration library for .NET

*This is not an official integration library from ImageKit.io. It is developed and maintained by the developer community with inputs from the ImageKit.io team. The list of contributors can be found below. Cheers to all of them!*

### Features
This library will help you to upload your images to ImageKit.io as easy as possible. Currectly you can upload images  via URL *(URi)*, Path to existing file in your hard disk *(string)*  and byte arrays *(byte[])* which are default format of uploaded files in ASP.NET .
Also you can make [feature request](#support) or [contribute](#contributing) for things you need.

## Getting Started
These instructions will help you to interact with ImageKit.io services in .NET using the brand new ImageKit.io integration library.

### Installing
There are a couple of ways to get started with this integration library.

Way one:
Open up your project, navigate to Nuget package manager console and add Imagekit package.
```
Install-Package Imagekit
```
Also you can search for [Imagekit](https://www.nuget.org/packages/Imagekit) in Nuget GUI.

Way two:

1-Clone this repo or download the zip file.

2-Add it to your solution

3-Reference your host project to Imagekit.

### Usage
Now that everything's installed and set up, you can start using ImageKit.io on your .NET project!
First, add this reference where you want to use imagekit.io services:
```cs
using Imagekit;
```
Then, initialize the imagekit.io service using this code, when your app starts(example: ASP: Global.asax, WPF: app.xaml.cs):
```cs
ConnectionHelper.Initialize("API-public", "API-Private", "ID");
```
Notice: API-public is your API public key, API-private is your API private key, and ID is your imagekit.io ID. You can get all of them from your [Imagekit.io dashboard](https://imagekit.io/dashboard).

#### Upload pictures
now you can upload your image using this code:
```cs
ImagekitResponse R = Upload.Picture(photo, "/path/", "name.jpg",true);
```
**Notice**: *photo* is your photo which can be a byte array *(byte[])* or your photo or local path on your disk *(string)* or a URL to an existing picture on the web *(URi)*. *"/path/"* is the desired path of uploaded file *(string)* . *"name.jpg"* is the desired name of uploaded file *(string)*. The last parameter is "useUniqueName" which is an optional parameter *(bool)* with the default value of *true*.

This method retunes you an object with the type of **ImagekitResponse** which is the information about the uploaded file.

| Name  | Description | Type | Sample output |
| ------------- | ------------- |------|------|
| ImagePath  | The path of uploaded picture in your media library  | string | "/avatar/sample_HJN0fTUtb.jpg" |
| Size  | Size of uploaded photo in bytes  | int | 7117 |
| Height  | Height of uploaded photo  | int | 200 |
| Width  | Width of uploaded photo  | int | 200 |
| ID  | The unique ID of your saved picture  | string | "HkiFvuZKZ/avatar/sample_HJN0fTUtb.jpg/original" |
| FileFolder  | The real path of uploaded picture in imagekit.io servers  | string | "/HkiFvuZKZ/avatar/sample_HJN0fTUtb.jpg/" |
| Thumbnail  | The thumbnail URL of uploaded picture  | string | "https://ik.imagekit.io/xeamo/tr:n-media_library_thumbnail/avatar/sample_HJN0fTUtb.jpg" |
| URL  | The public URL to your picture | string | "https://ik.imagekit.io/xeamo/avatar/sample_HJN0fTUtb.jpg" |
| Name  | The name of uploaded picture in your media library  | string | "sample_HJN0fTUtb.jpg" |
| Transformation  | The applied transformation to your picture  | string | "" |

Done; You uploaded your picture.
Whoa! It was so fast, wasn't it?

## Credits

* [Newtonsoft.Json](https://www.nuget.org/packages/Newtonsoft.Json/)

## Contributing

This library is an open source project, so all the modifications and contributions are welcome! Just make a fork of this repo, do your changes and make a pull request. We'll check your code ASAP.

## Support

If you have any kind of questions or feature request, you can contact [Mohsens22<EMAIL_ADDRESS>or contact [Imagekit.io](https://imagekit.io) via chat support.
Also you can post the issues in the [issues](https://github.com/imagekit-developer/dotnet-imagekit-integration/issues) part.

## Authors

* **Mohsen Seifi** - *Core development* - [@mohsens22](https://github.com/mohsens22)

See also the list of [contributors](https://github.com/imagekit-developer/dotnet-imagekit-integration/contributors) who participated in this project.

## License

This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details

repository: silverkea/dotnet-imagekit-integration

repo_name: silverkea/dotnet-imagekit-integration


text:
+++
title = "HTTP/2 Server Push Recipe"
description = "HTTP/2 server push recipe for Echo"
[menu.main]
  name = "HTTP/2 Server Push"
  parent = "cookbook"
+++

> Requires go1.8+

## How to send web assets using HTTP/2 server push?

### Step 1: [Generate a self-signed X.509 TLS certificate](/cookbook/http2#step-1-generate-a-self-signed-x-509-tls-certificate)

### Step 2: Register a route to serve web assets

```go
e.Static("/", "static")
```

### Step 3: Create a handler to serve `index.html` and push it's dependencies

```go
e.GET("/", func(c echo.Context) (err error) {
  pusher, ok := c.Response().Writer.(http.Pusher)
  if ok {
    if err = pusher.Push("/app.css", nil); err != nil {
      return
    }
    if err = pusher.Push("/app.js", nil); err != nil {
      return
    }
    if err = pusher.Push("/echo.png", nil); err != nil {
      return
    }
  }
  return c.File("index.html")
})
```

If `http.Pusher` is supported, web assets are pushed; otherwise, client makes separate requests to get them.

### Step 4: Configure TLS server using `cert.pem` and `key.pem`

```go
e.StartTLS(":1323", "cert.pem", "key.pem")
```

### Step 5: Start the server and browse to https://localhost:1323

```sh
Protocol: HTTP/2.0
Host: localhost:1323
Remote Address: [::1]:60288
Method: GET
Path: /
```

## [Source Code]({{< source "http2-server-push" >}})

`index.html`

{{< embed "http2-server-push/index.html" >}}

`server.go`

{{< embed "http2-server-push/server.go" >}}

## Maintainers

- [vishr](https://github.com/vishr)

repository: pratikmallya/echox

gha_license_id: MIT

repo_name: pratikmallya/echox


text:
---
title: Upgrade
uid: upgrade_service
description: Upgrade SuperOffice Customer Service to SuperOffice Service
author: {github-id}
keywords:
so.topic: guide
so.envir: onsite
# so.client:
---

# Upgrade SuperOffice Customer Service to SuperOffice Service

These are the recommended steps for upgrading SuperOffice Service / Customer Service.

## Before you begin

* Check the [system requirements][3] for SuperOffice Service
* [Upgrade your database][1] using ServerSetup.exe
* Upgrade CRM Win/Web
* [Upgrade the NetServer][2] used by Customer Service
* Download and unzip the Service installer package on your server

[!include[ALT](../../includes/warn-upgrade-all-to-same-version.md)]

**Using remote NetServer web services?**

We recommend using the same NetServer for both CRM Web and Service for a more lean administration.

**Want to use FASTCGI (recommended)?**

You need IIS version 7.5 or a patched version of 7.0. The Microsoft implementation of FastCGI functionality in IIS 7.0 is not correct.

## Step 1 - Run the installer to upgrade the software

1. Run the Customer Service installer.
2. Click the radio button for "Maintain or upgrade an existing instance".
3. Select the particular installation you want to upgrade in the list.
4. Click next.

![x -screenshot][img1]

> [!NOTE]
> When the installer finishes, you will need to run the upgrade.exe command. This must be done after every Customer Service upgrade, and the particulars for upgrading from version 7.5 to version 8.0 are explained in the next section.

### Customer center

When upgrading Service to a new version, your current [Customer center templates][4] will be copied to a new folder called *templates_date_time*.

If you have made customizations to the customer center, you will need to update the current templates folder, which will have the new optimizations, but the standard design.

## Step 2 - Run upgrade.exe to update the database

When the installer is done upgrading the files to version 8.0, you need to run the command [upgrade.exe][5] from a shell prompt.

> [!NOTE]
> The command **upgrade.exe must always be run after an upgrade** as it might perform configuration or data transformation tasks. There is no harm in running upgrade.exe more than once as it will keep tabs on what is done already and what is not.<br>It must be run **with elevated/admin rights**, or you might get errors during the upgrade process because upgrade.exe may not be allowed to do certain changes to the system.

1. Run cmd.exe from the start menu.
    * Make sure the upgrade.exe process is run with elevated/admin rights!
    * You may have to start cmd.exe with a right-click on a shortcut and select run as administrator to achieve this.
2. Navigate to the *bin* directory in the Customer Service installation folder to find and start upgrade.exe.
3. The upgrade.exe program will ask you some questions of which there are 3 main new areas of interest: website name, FastCGI, and attachments (described below).
4. Flush the cache: Navigate to `http://your-site/scripts/rms.exe?action=debug` and click **Flush caches** at the bottom.

![x -screenshot][img2]

### The website name

Upgrade will ask you for the IIS site name and will check to see if it exists. This is not the same as the domain name - it is the name of the site in the IIS manager.

### FastCGI

> [!CAUTION]
> **We recommend you run Customer Service using FastCGI technology.** FastCGI is more efficient and will increase application responsiveness and decrease server load. It requires some additional IIS settings to be done and upgrade.exe will attempt to do this for you. If upgrade.exe encounters problems with your IIS version or administrative privileges, it will try to warn you and offer to abort the upgrade process so you can fix the issue and re-run upgrade.exe. The upgrade.exe program will also tell you if your IIS needs a Microsoft patch or hotfix, and print some URLs of where to download it if necessary.

When using FastCGI, the webserver does not need to start a new process for each request. The process is instead alive in memory for a while retaining some of its data and only needing to process a lot of initialization logic once and not for each request. This significantly improves responsiveness and decreases server load.

There is an additional benefit to using another extension than .exe and that is that Customer Service links in emails, also e-marketing emails, will not be viewed as a potential threat by spam detection filters the same way a .exe file extension URL would.

**The upgrade.exe process will ask if you want to set up FastCGI.** If you choose to do so it will try to configure your IIS site as this can be tedious to do manually as it involves mapping each .exe file to an empty place holder .fcgi file in IIS FastCGI setup. This is done on the IIS site/application level and it's preferable to let upgrade.exe set this up automatically and later change timeout settings, and so on. if one wishes from the IIS manager FastCGI settings section.

After configuring FastCGI, Customer Service will generate URLs that end in .fcgi instead of .exe but the .exe file ending will also work. If you decide you do not want to use FastCGI after all, you can just change a setting in the Registry table in the database. Then the .exe links will be generated instead of .fcgi and everything will work as before.

### Attachments

Upgrade.exe will want to remap attachment files to sub-folders and this might take some time if you have many and/or large files. You can choose to skip this step and run upgrade.exe later if you are not prepared to keep your site down until all your attachment files are moved into place.

The attachment folder can potentially have hundreds of thousands of files, which might make it inefficient and difficult to browse manually with a file manager, and we will now store them in sub-directories with a maximum of 10.000 files in each. Which folder each file is allocated to depends on the file ID number, the first 10.000 numbers go into the first folder, and so on. This means that there may be less than 10.000 files in any attachment sub-folder if some of the IDs are not in use or if an attachment was deleted. You can opt to delay moving the attachments if you expect it to take a lot of time, so you can unfreeze your Customer Service site quicker. Run upgrade.exe later to complete this process.

<!-- Referenced links -->
[1]: ../../onsite/upgrade/75-to-8/crm-server.md
[2]: ../../onsite/upgrade/75-to-8/web-client.md
[3]: ../../onsite/requirements/crm-server.md
[4]: ../../customer-center/templates.md
[5]: ../automated-tasks/upgrade.md

<!-- Referenced images -->
[img1]: media/upgradeservice.png
[img2]: media/capture.png

repository: ArildEik/superoffice-docs

branch_name: refs/heads/main

repo_name: ArildEik/superoffice-docs


text:
---
title : "Native applications"
date :  2019-09-12T13:18:58+02:00
weight : 5
---

# Interacting with a native application

Now that we have covered how to interact with an operating system and used screenshot based testing
capabilities of Sakuli, we can move on how to utilize one or multiple applications.
All features are incorporated in the ThenableApplication Interface.

### Open an application

To open an application, you enter the path to the application or respectively the application name, if you already
added it to your PATH environment variable. If your path contains spaces, you have to escape them with `\\` because white spaces are reserved for parameter separation.
{{< highlight typescript >}}
// path to excel 'C:\\path to excel \excel.exe'
const excel = new Application("C:\\path\\ to\\ excel\excel.exe");
await excel.open();

// open browser with parameters
const chromium = new Application("chromium-browser --incognito --proxy-server=localhost:1234");
await chromium.open();

// path to chrome is e.g. 'C:\\Program\\ Files\google-chrome\chrome.exe'
const chrome = new Application("C:\\Program\\ Files\google-chrome\chrome.exe --incognito");
await chrome.open();
{{< /highlight >}}

After creating an application with `new Application()`, it is necessary to call `open()` for Sakuli to start it.

With `setSleepTime(seconds)` you can set the waiting time after opening an application. This is particularly useful for
larger applications that have an initial loading time.
{{< highlight typescript >}}
const calc = new Application("gnome-calculator");
//sleepTime of 1 second
await calc.setSleepTime(1)
    .open();
{{< /highlight >}}

### Closing an application
You can either use `close()` or `kill()`. `close()` sends a `SIGTERM` signal and `kill()` a `SIGKILL` signal to end the
process.

{{< highlight typescript >}}
await calc = new Application('gnome-calculator').open();

await calc.close();
await calc.kill();

//throws an exception if ending the process fails
await calc.close(false);
await calc.kill(false);
{{< /highlight >}}

### Combining with Region

Currently (Sakuli v2.3.0) it is not possible to get the region from the application or the focused window. Therefore the
following methods will return the desktop instead.

{{< highlight typescript >}}
const calc = new Application('gnome-calculator');

await calc.open()
    .getRegion();

await calc.open()
    .getRegionForWindow();
{{< /highlight >}}

repository: sakuli/docs

branch_name: refs/heads/develop

gha_language: CSS

repo_name: sakuli/docs


text:
[![Build Status](https://github.com/ishepard/pydriller/workflows/Pydriller%20workflow/badge.svg?event=push&branch=master)](https://github.com/ishepard/pydriller/actions)
[![Documentation Status](https://readthedocs.org/projects/pydriller/badge/?version=latest)](https://pydriller.readthedocs.io/en/latest/?badge=latest)
[![codecov](https://codecov.io/gh/ishepard/pydriller/branch/master/graph/badge.svg)](https://codecov.io/gh/ishepard/pydriller)
[![Downloads](https://pepy.tech/badge/pydriller/month)](https://pepy.tech/project/pydriller)
[![Language grade: Python](https://img.shields.io/lgtm/grade/python/g/ishepard/pydriller.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/ishepard/pydriller/context:python)

# PyDriller

PyDriller is a Python framework that helps developers in analyzing Git repositories. With PyDriller you can easily extract information such as commits, developers, modifications, diffs, and source codes.

![Alt Text](https://ishepard.github.io/images/mygif.gif)

## Table of contents
* **[How to cite PyDriller](#how-to-cite-pydriller)**
* **[Requirements](#requirements)**
* **[Install](#install)**
* **[Source code](#source-code)**
* **[Tutorial](#tutorial)**
* **[How to contribute](#how-to-contribute)**

## How to cite PyDriller

```
@inproceedings{Spadini2018,
	address = {New York, New York, USA},
	author = {Spadini, Davide and Aniche, Maur\'{i}cio and Bacchelli, Alberto},
	booktitle = {Proceedings of the 2018 26th ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering - ESEC/FSE 2018},
	doi = {10.1145/3236024.3264598},
	isbn = {9781450355735},
	keywords = {2018,acm reference format,and alberto bacchelli,davide spadini,git,gitpython,maur\'{i}cio aniche,mining software repositories,pydriller,python},
	pages = {908--911},
	publisher = {ACM Press},
	title = {{PyDriller: Python framework for mining software repositories}},
	url = {http://dl.acm.org/citation.cfm?doid=3236024.3264598},
	year = {2018}
}

```

## REQUIREMENTS
Very few! Just:

- Python3
- Git

The list of dependencies is shown in `./requirements.txt`, however the installer takes care of installing them for you.

## INSTALL

Installing PyDriller is easily done using pip. Assuming it is installed, just run the following from the command-line:

```
pip install pydriller
```
This will also install the necessary dependencies.

## SOURCE CODE

If you like to clone from source, you can do it with very simple steps.
First, clone the repo:

```
> git clone https://github.com/ishepard/pydriller.git
> cd pydriller
```

### OPTIONAL

It is suggested to make use of `virtualenv`:

```
> virtualenv -p python3 venv
> source venv/bin/activate
```

### INSTALL THE REQUIREMENTS AND RUN THE TESTS

Install pydriller and the requirements:

```
> python setup.py install
```

to run the tests (using pytest):

```
> pip install -r test-requirements.txt
> unzip test-repos.zip
> pytest
```

## TUTORIAL
For information on how to use PyDriller, refer to the official documentation:

- [http://pydriller.readthedocs.io](http://pydriller.readthedocs.io)
- a video on Youtube: [https://www.youtube.com/watch?v=7Oui4bP9eN8](https://www.youtube.com/watch?v=7Oui4bP9eN8)

## How to contribute
Fork the project and follow the instructions on how to get started with [source code](#source-code). I tend to not accept a Pull Request without tests, so:

- unzip the `test-repos.zip` zip file
- inside you will find many "small repositories" that I manually created to test PyDriller. Choose the one you prefer the most, and test your feature (check the tests I have already written, you'll find inspiration there)
- if you do not find a repository that is suitable to test your feature, create a new one. **Be careful**: if you create a new one, do not forget to upload a new zip file `test-repos.zip` that includes your new repository, otherwise the tests will fail.

## License

This software is licensed under the Apache 2.0 License.

This project has received funding from the European Unions’ Horizon 2020 research and innovation programme under the Marie Sklodowska-Curie grant agreement No. 642954.

repository: sinaneski/pydriller

repo_name: sinaneski/pydriller


text:
# General best practices
Writing code to follow best practices is at the heart of good coding practice. Highlighted below are a few of the things you would need to look out for when reviewing code.

- **DRY (Don’t Repeat Yourself)**
Code should be DRY. Just like earlier mentioned, you need to ask the question “Is there redundant or duplicate code?”. Ensure that unnecessary repetitions don’t exist within the code base.

- **Object Oriented Programming**
Follow [SOLID principles](http://code.tutsplus.com/series/the-solid-principles--cms-634) for writing object oriented programs. At the very least, we should ensure that programs have high cohesion and loose coupling.

- **Documenting Code**
Code is expected to be thoroughly documented. Always use doc style comments if possible but also write code in a way that you may require little or no comments.

- **Separation of Concerns**
Technically, you could write an entire application code within a single file. But that would prove to be a nightmare to read and maintain. Ensure that your code is always broken into logical containers, properly arranged within folders. This makes it far easier to navigate through your codebase.

repository: AnayoOleru/awesome-code-guidelines

repo_name: AnayoOleru/awesome-code-guidelines


text:
# How to configure clients, scopes and APIs for Omahelsinki

## 1. Configure an OIDC client for the profile

In tunnistamo’s admin panel go to “OpenID Connect Provider” → “Client” → “Add”:

- give it any name you want

- choose “Confidential” client type

- choose “it_token token (Implicit Flow)” response type

- give it any redirect url (they won’t actually be used)

- put `https://api.hel.fi/auth/profiles` as “Client ID” (precisely this, or you won’t be able to connect it to an API later on)

- choose your social media platform  as “Login method”

- choose some “Site type”

Once you click “save”, Django will generate “Client SECRET” for this Client. Example:

![profile client settings](profile-client-settings.png)

## 2. Configure an OIDC client for Omahelsinki

In tunnistamo’s admin panel go to “OpenID Connect Provider” → “Client” → “Add”:

- give it any name you want

- choose “Confidential” client type

- choose “code (Authorization Code Flow)” response type

- give it `http://localhost:<PORT>/complete/tunnistamo/` as redirect url

- put any string as “Client ID”

- put these into the “Scopes” field: `https://api.hel.fi/auth/profiles login_entries consents email profile`
(exactly these, exactly like that, without any commas)

- choose your social media platform  as “Login method”

- choose some “Site type”

Once you click “save”, Django will generate “Client SECRET” for this Client. Example:

![omahelsinki client settings](omahelsinki-client-settings.png)

## 3. Configure API scope for the profile backend

- in tunnistamo’s django admin panel go to “OIDC APIS” → “API domains” → “Add”.
Create a domain with the following identifier: `https://api.hel.fi/auth`.

    NOTE: this is not going to be used in any links, it is just an identifier, you
    do not need any actual access to this domain.

![API domain](api-domain.png)

- go to “OIDC APIS” → “APIs” → “Add”. Create an API with the following settings:

    - `https://api.hel.fi/auth` as domain

    - `profiles` as name

    - “Sähköposti / Email” and “Profile” in “Required scopes”

    - the profile client you created in the 1 step as “OIDC client”

BEWARE: there is currently a bug (probably, maybe): that even though UX suggests
“OIDC client” is an optional field, it is actually REQUIRED. AND the client’s “Client ID”
has to be equal to this API’s `domain/name` combination,
i.e. `https://api.hel.fi/auth/profiles`

![API](api.png)

- go to “OIDC APIS” → “API scopes” → “Add”. Create a scope with the following settings:

    - `https://api.hel.fi/auth/profiles` as “API”

    - give it any name you want

    - give it any description you want

    - choose your Omahelsinki client (the one you created in step 2) in the
    “Allowed applications” field

Once you click “save”, Django will generate an identifier for this scope. The settings
should eventually look like this:

![API scope](api-scope.png)

## 4. Configure your local instance of profile to use local instance of Tunnistamo

Before starting the Docker containers, you have to have `.env` file in the root folder
of the project with the following variables:

```bash
API_SCOPE_PREFIX=profiles
OIDC_CLIENT_ID=https://api.hel.fi/auth/profiles
OIDC_SECRET=<your-secret>
OIDC_ENDPOINT=http://tunnistamo-backend:<your-port>/openid
```

NOTE: copy the generated secret from the OIDC client you set up in step 1.

## 5. Configure your local instance of Omahelsinki to use local instances of Tunnistamo and profile

In the root folder of the project you should have a `local_settings.py` file with
the following variables:

```python
TUNNISTAMO_BASE_URL = 'http://tunnistamo-backend:<your-tunnistamo-port>'
SOCIAL_AUTH_TUNNISTAMO_KEY = '<your-client-id>'
SOCIAL_AUTH_TUNNISTAMO_SECRET = '<your-secret>'
SOCIAL_AUTH_TUNNISTAMO_OIDC_ENDPOINT = TUNNISTAMO_BASE_URL + '/openid'
PROFILE_API_URL = 'http://localhost:<your-profile-port>/v1'
```

NOTE: copy the “Client ID” and the generated secret from the OIDC client you set up
in step 2.

`PROFILE_API_URL` can use `localhost` because this variable will be used by the JS
code directly in the browser, so it can access it through this address.

Now, you can start all your docker containers and you should be able to log in into
the Omahelsinki profile.

repository: frwickst/omahelsinki

repo_name: frwickst/omahelsinki


text:
# strip-bytes-stream

strip bytes from a stream according to a predicate

## Usage

```js
require('strip-bytes-stream') => (predicate) => stream
```

### `stream.total`

Holds a running total of removed bytes, see example for use case.

## Example

Strip bytes with values between 96 and 99 inclusive (remove a, b, c and chars)

```js
var sbs = require('strip-bytes-stream')

process.stdin
  .pipe(sbs(n => n < 96 || n > 99))
  .on('end', function () {
    console.log(this.total + ' bytes removed')
  })
  .pipe(process.stdout)
```

```sh
echo "abcdef" | node example.js
def
3 bytes removed
```

## Support

Node v4+

## License

MIT

## Acknowledgements

* Sponsored by nearForm

repository: davidmarkclements/strip-bytes-stream

repo_name: davidmarkclements/strip-bytes-stream


text:
---
layout: "unit"
title: "Guide Entry 93.02.10"
path: "/curriculum/guides/1993/2/93.02.10.x.html"
unitTitle: "Folktales of Zora Neale Hurston"
unitAuthor: "Mary Ellen Riccio"
keywords: "Afro-American Zora Neale Hurston Literature Women Authors Folktales"
recommendedFor: "Recommended for Literature or American History, Grades 6-12"
---

Guide Entry to 93.02.10:

The primary focus of my unit will be Zora Neale Hurston’s Afro-American folktales. Her writings capture the flavor and culture of the rural black town of Eatonville, Florida, where she was born and raised. Her folktales reveal the unique customs, speech and humor of the townspeople.

I will use her book “Mules and Men” as the primary source of her folktales. I have already read my class some folktales from her book. They were spellbound. She portrays the culture of Eatonville, Florida exactly and beautifully in this book. This world is far removed from the students’ life experiences in New Haven. The people of Eatonville are proud of their town and their heritage. Within the town, everyone has a sense of dignity and importance. Her stories and folktales illustrate how an entire group of people adapted and survived in America, how they modified what they found into a different lifestyle and the behavior the group approves of. Her stories do not deal with race relations, but rather the essence of individuals.

I plan to read most of the stories, or folktales, in this book to my class. I will also include lessons which spark the students’ imagination and creativity.

(Recommended for Literature or American History, Grades 6-12)

Key Words

Afro-American Zora Neale Hurston Literature Women Authors Folktales

gha_language: HTML


text:
# Contributing

- Setup codeclimate cli on your workstation
- Run `docker build -t codeclimate/codeclimate-black .` from within this repository
  to build this docker image
- Register the plugin with `codeclimate engines:install black`
- Run `codeclimate analyze --dev` to run it against your repository

repository: rabisg/codeclimate-black

repo_name: rabisg/codeclimate-black


text:
# 338. Counting Bits

> Medium

------

Given a non negative integer number `num`. For every numbers `i` in the range `0 ≤ i ≤ num` calculate the number of `1`s in their binary representation and return them as an array.

**Example 1:**

```
Input: 2
Output: [0,1,1]
```

**Example 2:**

```
Input: 5
Output: [0,1,1,2,1,2]
```

path: /Medium/338. Counting Bits/README.md


text:
# Get CKB

We have CI to ensure CKB works in following systems, they are also the
recommended system to run CKB.

OS           | Arch
-------------|------
Ubuntu 16.04 | x64
macOS        | x64
Windows\*    | x64

> \* Support for Windows is experimental. CKB is known to have serious performance
> issues when running in Windows.

CKB should also work on any modern Linux distributions. However, we limit our
energy to focus on the support of following systems:

OS             | Arch
---------------|------
Ubuntu 18.04   | x64
Debian Stretch | x64
Arch Linux     | x64
CentOS 7       | x64

You can also [use docker](run-ckb-with-docker.md) if your operating system is
not properly supported by CKB for now.

## Download from Releases

We will publish binaries for each release via [Github Releases]. If your system
is listed there, you can download the package directly.

CKB releases are signed. It is wise and more secure to check out for their [integrity](integrity-check.md).

[Github Releases]: https://github.com/nervosnetwork/ckb/releases

CentOS users please use the `x86_64-unknown-centos-gnu` package, which also
requires OpenSSL 1.0 to run:

```shell
sudo yum install openssl-libs
```

The Windows packages are for experiments only, they have significant
performance issues, we don't recommend to use them in production environment.
They requires *The Visual C++ Redistributable Packages*, which can be downloaded
under section *Other Tools and Frameworks*
[here](https://visualstudio.microsoft.com/downloads/) or
[here](https://www.microsoft.com/en-us/download/details.aspx?id=48145).

## Build from Source

### Install Build Dependencies

CKB requires Rust to build. We recommend installing [rustup](https://www.rustup.rs/) to manage Rust versions.

The required Rust version is saved in the file `rust-toolchain`. If rustup is
available, it will pick the right version automatically.

You also need to get the following packages：

#### Ubuntu and Debian

```shell
sudo apt-get install -y git gcc libc6-dev pkg-config libssl-dev libclang-dev clang
```

#### Arch Linux

```shell
sudo pacman -Sy git gcc pkgconf clang
```

#### macOS

```shell
brew install autoconf libtool
```

#### CentOS

```shell
sudo yum install -y centos-release-scl
sudo yum install -y git make gcc-c++ openssl-devel llvm-toolset-7
```

Start a shell enabling clang

```shell
scl enable llvm-toolset-7 bash
```

Remember to run following commands in this console.

#### Windows

Install Visual Studio with Desktop C++ workload, and install following
packages via [Chocolatey](https://chocolatey.org)

```
choco install -y llvm msys2
```

### Add Environment Variables

If your OS contains pre-compiled `rocksdb` or `snappy` libraries,
you may setup `ROCKSDB_LIB_DIR` and/or `SNAPPY_LIB_DIR` environment variable
to point to a directory with these libraries.
This will significantly reduce compile time.

```shell
export ROCKSDB_LIB_DIR=/usr/local/lib
export SNAPPY_LIB_DIR=/usr/local/lib
```

### Build from source

The `master` branch is regularly built and tested. It is always the latest
released version. The default checked out branch `develop` is the latest
version in active development.

It is recommended to build a version from master.

You can download the source code of [master
branch](https://github.com/nervosnetwork/ckb/archive/master.zip) from GitHub,
or a history version from [GitHub Releases].

You also can choose to clone the code via git:

```bash
# get ckb source code
git clone https://github.com/nervosnetwork/ckb.git
cd ckb
git checkout master
```

It is easy to switch to a history version and build, for example, check out
v0.12.2.

```bash
git checkout -b branch-v0.12.2 v0.12.2
```

Run `make prod` inside the source code directory. It will build the executable
`target/release/ckb`. Please add the directory to `PATH` or copy/link the file
into a directory already in the `PATH`.

```bash
export PATH="$(pwd)/target/release:$PATH"
# or
# ln -snf "$(pwd)/target/release/ckb" /usr/local/bin/ckb
```

In Windows, use `cargo build --release` instead and the executable is
`target/release/ckb.exe`.

repository: SPERAXIO/ckb

repo_name: SPERAXIO/ckb


text:
vu-editor
=========

Pragmatic programming editor. [![Build Status](https://travis-ci.org/RomanBoiko/vu-editor.png)](https://travis-ci.org/RomanBoiko/vu-editor)

Distributed under [The MIT License](http://roman-boiko.mit-license.org).

[Executable Jar](https://github.com/RomanBoiko/vu-editor/blob/master/vue.jar?raw=true) [![endorse](https://api.coderwall.com/romanboiko/endorsecount.png)](https://coderwall.com/romanboiko)

Usage
-----

- Download [editor jar](https://github.com/RomanBoiko/vu-editor/blob/master/vue.jar?raw=true)
- In most cases (depends on OS setup) you can start it by double clicking on downloaded file.
- As an alternative - in console: ```java -jar <path to downloaded vue.jar> [path to file to edit]```
- To see editor shortcuts - please use ```Alt+H``` while in editor

Features:
---------

- [x] - ready
- [ ] - not ready yet

---

- [x] full editor packaged into single shell file(POSIX package)
- [x] full editor in executable jar(Windows package)
- [x] no third-party libs, core java
- [x] show line numbers
- [x] XML formatting
- [x] open with file from command line
- [x] save file
- [x] save all open files
- [x] line up/down
- [x] delete line
- [x] show whitespaces
- [x] join lines
- [x] help system
- [x] ESC to return to edit mode
- [x] license
- [x] log file
- [x] handling(logging) all exceptions/errors
- [x] exit from editor shortcut(not dependant on window manager's abilities)
- [x] to upper/lower case
- [x] file explorer(tree)
- [x] multiple buffers/documents, switch between them
- [x] close current buffer (close file under edit)
- [x] matching Bracket highlight
- [x] showing file name under edit in title on alt+tab
- [x] show opened file path in status bar
- [x] undo
- [x] redo
- [x] multiline indent
- [x] multiline unindent
- [x] duplicate lines
- [x] open stream from command line (use in pipe)
- [x] mark file with unsaved changes. Save unsaved file before close. Save all unsaved files before exit
- [x] change root folder in explorer
- [x] copy current file path/name into clipboard
- [x] search in file (case sensitive/insensitive/by regexp)
- [x] set working directory as selected dir in FileExplorer
- [x] search in folder results in separate mode with navigation to editor
- [ ] replace in file
- [ ] vertical edit
- [ ] highlight words similar to the one under cursor
- [ ] goto occurences of the word under cursor
- [ ] open file by name(fuzzy)
- [ ] outlines(list of functions, paragraphs)
- [ ] auto-refactoring
- [ ] any command menu
- [ ] use spaces instead of tabs
- [ ] line wrapping
- [ ] syntax highlight(config)
- [ ] config

Known bugs:
-----------

- [x] fixed
- [ ] not fixed yet

---

- [x] 1. Selected text becomes unvisible when switching whitespace highlight off (reported by Samir Talwar)
- [ ] 2. Few line numbers appear in the same raw - not reproduced yet, maybe due to font size/resolution (reported by Grzegorz Ligas)
- [x] 3. After switching from help back to edit area file is reloaded and because of that not saved changes are lost
- [x] 4. If we are in read-only perspective(i.e. Help), and doing Alt+Tab, and than coming back to Editor - cursor is not visible any more, even if to come back to EditorPerspective(with Esc). Workaround: after switching to EditorPerspective - do Alt+Tab twice
- [x] 5. after folder is opened in FileExplorer - cursor jumps to last child of this folder
- [x] 6. CTRL+SHIFT+TAB removes focus from text area and removes key listener
- [ ] 7. Regexp doesn't find if it matches text in the end of file

repository: RomanBoiko/vu-editor

repo_name: RomanBoiko/vu-editor


text:
# So Smol CMS
Lightweight blog platform - a work in progress
*The best place to start looking at the code is in 'includes/Controllers/App/Posts.php'*

## Where are the PHP/JS/HTML files ?

### PHP
All the back-end code is inside the 'includes' folder
You'll find the code for Models and the framework itself in the 'Library' directory

### JS
Routing is done in the 'templates/js/app.js' file, with all the other code being in the 'templates/js/app' folder
All JS dependencies are merged into a single file to minimise load time

### HTML
All HTML is broken up into partials that are then put in JSON format to make it easier for Backbone to read
The raw HTML is found in 'templates/partials', while 'templates/partials-compiled' contains the JSON formatted ones

## How does it work ?

An Ori powered REST API feeds all data into a Backbone front-end
The best place to start looking at the code is in 'includes/Controllers/App/Posts.php'

## Does this use any other libraries ?

The [PHPAuth library](https://github.com/PHPAuth/PHPAuth) is used to provide secure user authentication

## TODO

* Fix any other OWASP Top 10 vulns
* Add markdown editor for posts
* Add markdown rendering to the front-end

repository: phil-jauvin/sosmolcms

repo_name: phil-jauvin/sosmolcms


text:
# DEM-SR
Name of code：“DEM-RSPCN.py”

Developer and contact address: Ruichen Z.
year first available：2020
revised version available: March 2021
hardware required：Win 10
software required：Tensorflow 6.0, python3.8 64bit
program language：c++, python
program size: 4KB

Digital elevation model (DEM) is known as one of the most significant fundamental geographical data,
the theory, method and application of which are hot research issues in geography, especially in
geomorphology, hydrology, soil and other fields. Thanks for the technical support from the Book
“Getting Started and Best Practices with Tensor-flow for Deep Learning”.

The CODE introduces a new method RSPCN of “DEM super-resolution”, which reconstructs high-resolution DEM form low-resolution DEM.

repository: hechengyan/DEM-SR

repo_name: hechengyan/DEM-SR


text:
# Plain SMTP Mailer for Laravel 5+
Custom mail driver for [Laravel 5+](http://www.laravel.com/) working with SMTP server via a socket.

## Installation
The Plain SMTP Mailer can be installed via [Composer](http://getcomposer.org) by requiring the
`fractal512/plain-smtp-mailer` package:
```
composer require fractal512/plain-smtp-mailer
```
or add `fractal512/plain-smtp-mailer` to `require` section and set the `minimum-stability` to `dev` (required for Laravel 5) in your project's `composer.json`:
```json
{
    "require": {
        "laravel/framework": "5.0.*",
        "fractal512/plain-smtp-mailer": "^1.0"
    },
    "minimum-stability": "dev"
}
```
then update your packages with `composer update` or install with `composer install`.

## Registration in Laravel
No need in versions with auto discovery (Laravel 5.5+).
Register the Plain SMTP Mailer Service Provider in the `providers` key in `config/app.php`.

```php
    'providers' => [
        // ...
        'Fractal512\PlainSmtpMailer\PlainSmtpMailerServiceProvider',
    ]
```
for Laravel 5.1+
```php
    'providers' => [
        // ...
        Fractal512\PlainSmtpMailer\PlainSmtpMailerServiceProvider::class,
    ]
```

## Configuration
Publish the package `mailer.php` config file to apply your own settings.
```shell script
$ php artisan vendor:publish --tag=mailerconfig
```
or run (Laravel 8+)
```shell script
$ php artisan vendor:publish
```
then enter the number of the `Fractal512\PlainSmtpMailer\PlainSmtpMailerServiceProvider` service provider.

Options in config file refer to options for mail driver in the app `.env` file:
```text
MAIL_DRIVER=PlainSmtpMailer
MAIL_DOMAIN=example.com
MAIL_HOST=smtp.example.com
MAIL_PORT=25
<EMAIL_ADDRESS>MAIL_PASSWORD=12345678
MAIL_CLIENT="Desired mail client full name like: Outlook Express (v1.0)...|The Bat! (v1.0)...|Mozilla Thunderbird (v1.0)... etc."
MAIL_ENCRYPTION=null
```

## Usage
You need configured SMTP server with account created on your hosting.
You can use built in Laravel mail functionality with Plain SMTP Mailer, just enable `PlainSmtpMailer` driver in `.env` by setting:
```text
MAIL_DRIVER=PlainSmtpMailer
```
and adding all the other needed options in MAIL section as shown in `Configuration` section above.


text:
# My local project stack (PHP7-FPM - NGINX - MySQL)

This is the local environment I develop my open-source little tinker projects in. It has everything you need for developing simple web applications. This complete stack runs with [docker](https://docs.docker.com/get-started/) and [docker-compose](https://docs.docker.com/compose/) (1.7 or higher).

* [Installation](#installation)
* [Usage](#usage)
* [Customize](#custom)
* [How it works?](#explanation)
* [Useful commands](#useful-commands)

## Installation

1. Create a `config.env` from the `config.env.dist` file. Adapt it according to your needs.

    ```bash
    cp config.env.dist config.env
    ```

2. Build/run containers (with or without detached mode -d)

    ```bash
    $ docker-compose build
    $ docker-compose up -d
    ```

3. Update your system host file (add local.project)

    ```bash
    # UNIX only: get containers IP address and update host (replace IP according to your configuration)
    $ sudo echo $(docker network inspect bridge | grep Gateway | grep -o -E '[0-9\.]+') "local.project" >> /etc/hosts
    # on Windows, edit C:\Windows\System32\drivers\etc\hosts
    ```

5. Enjoy :-)

## Usage

Just run `docker-compose up -d`, then:

* app front page: visit [local.project](http://local.project)
* phpmyadmin panel: visit [local.project:8080](http://local.project:8080)

## Customize

If you want to add optional containers like Redis, Elk(Kibana) etc. take a look on [docs/custom.md](docs/custom.md).

## How it works?

Have a look at the `docker-compose.yml` file, here are the `docker-compose` built images:

* `local_mysql`: This is the MySQL database container,
* `local_php`: This is the PHP-FPM container in which the application volume is mounted,
* `local_nginx`: This is the Nginx webserver container in which application volume is mounted too,
* `local_phpmyadmin`: This is the phpmyadmin container, which is linked to the MySQL database container, and gives you easy access to the database right from your browser.

This results in the following running containers:

```bash
$ docker ps

CONTAINER ID    IMAGE                   COMMAND                         PORTS                            NAMES
d483043e19ee    phpmyadmin/phpmyadmin   "/run.sh supervisord…"          9000/tcp, <IP_ADDRESS>:8080->80/tcp   local_phpmyadmin
82f49b22e220    php7.0_xdebug           "docker-php-entrypoi…"   ...    9000/tcp                         local_php
bdd30bc97851    percona:5.6             "docker-entrypoint.s…"                                           local_mysql
e10b4b22a4d9    nginx:latest            "nginx -g 'daemon of…"

repository: sociaqui/myStack

repo_name: sociaqui/myStack


text:
# Another command line LDAP client - llcd

The goal of this project is a command client for LDAP server. The client is
written in [Ruby](http://ruby-lang.org "Ruby") by using
[Net::LDAP](http://rubyldap.com "net-ldap") and
[ncursesw](http://ncurses-ruby.berlios.de "ncursesw").

repository: schaary/llcd

repo_name: schaary/llcd


text:
# localstorage-down [![Build Status](https://travis-ci.org/No9/localstorage-down.svg)](https://travis-ci.org/No9/localstorage-down) [![Coverage Status](https://coveralls.io/repos/No9/localstorage-down/badge.svg?branch=master&service=github)](https://coveralls.io/github/No9/localstorage-down?branch=master)

LocalStorage implementation of [leveldown](https://github.com/Level/leveldown) for mobile and desktop browsers. The idea is to be able to use the [level](http://github.com/level) stack on any browser that supports LocalStorage.

The scenarios envisaged are:

1. Occasionally connected clients
2. Ad-hoc networks where clients need to sync directly with each other

This project is intended for use with the [level eco-system](https://github.com/level/).

## Install

```
npm install localstorage-down
```

## Browser support

Basically we support [any browser that has LocalStorage](http://caniuse.com/namevalue-storage), but since we also rely on an ES5 environment due to dependencies from [abstract-leveldown](https://github.com/Level/abstract-leveldown), in practice you will need the following shims in order to work correctly on all browsers (e.g. IE 8-9, Android 2.3):

* [typedarray](https://github.com/substack/typedarray) for binary storage
* [es5-shim](https://github.com/es-shims/es5-shim) for just about everything

We run [automated tests](http://travis-ci.org/No9/localstorage-down) in the following browsers:

* **Firefox**: 40-latest
* **Chrome**: 44-beta
* **IE**: 9-11
* **Edge**: latest
* **Safari**: 7.0-latest
* **iPhone**: 8.0-latest
* **Android**: 4.1-latest

In environments without LocalStorage, such as Node or Safari private browsing, this module
will fall back to a temporary in-memory implementation, thanks to [humble-localstorage](https://www.npmjs.com/package/humble-localstorage).

## Example

At the command prompt in your chosen directory :

    npm install localstorage-down
    npm install levelup
    npm install browserify -g
    npm install beefy -g

Create a file called `index.js` and enter the following:

```js
var localstorage = require('localstorage-down');
var levelup = require('levelup');
var db = levelup('dbname', { db: localstorage });

db.put('name', 'James Dean');
db.put('dob', 'February 8, 1931');
db.put('occupation', 'Rebel');
db.put('cause', 'none');

db.readStream()
   .on('data', function (data) {
      if (typeof data.value !== 'undefined') {
         console.log(data.key, '=', data.value);
      }
   })
   .on('error', function (err) {
      console.log('Oh my!', err);
   })
   .on('close', function () {
      console.log('Stream closed');
   })
   .on('end', function () {
     console.log('Stream ended');
   });
```

Publish the site :

    beefy index.js

See the output :

[http://localhost:9966](http://localhost:9966)

Listen to John Cage:

https://www.youtube.com/watch?v=9hVFCmK6GgM

## Tests

    npm run test

This will run tests in Node against `localstorage-memory`.

To test in Saucelabs, you can run e.g.:

    BROWSER_NAME=firefox BROWSER_VERSION="38..latest" npm run test-saucelabs

Or to test in Zuul locally:

    npm run test-zuul-local

To test and check code coverage, run:

    npm run coverage

To test and report code coverage to Coveralls, run:

    npm run report-coverage

##  Contributors

* [Anton Whalley](https://github.com/no9)
* [Adam Shih](https://github.com/adamshih)
* [Nolan Lawson](https://github.com/nolanlawson)
* [Many more!](https://github.com/No9/localstorage-down/graphs/contributors)

repository: Upquant/help

repo_name: Upquant/help


text:
# Leaflet.FeatureGroup.SubGroup
Creates a Leaflet Feature Group that adds its child layers into a parent group
when added to a map (e.g. through L.Control.Layers).

[![GitHub releases](https://img.shields.io/github/release/ghybs/leaflet.featuregroup.subgroup.svg?label=GitHub)](https://github.com/ghybs/Leaflet.FeatureGroup.SubGroup/releases)
[![npm](https://img.shields.io/npm/v/leaflet.featuregroup.subgroup.svg)](https://www.npmjs.com/package/leaflet.featuregroup.subgroup)
[![license](https://img.shields.io/github/license/ghybs/leaflet.featuregroup.subgroup.svg)](https://github.com/ghybs/Leaflet.FeatureGroup.SubGroup/blob/master/LICENSE)

[https://github.com/ghybs/Leaflet.FeatureGroup.SubGroup](https://github.com/ghybs/Leaflet.FeatureGroup.SubGroup)

## Demos
- [SubGroup with standard L.Control.Layers and MarkerCluster](https://ghybs.github.io/Leaflet.FeatureGroup.SubGroup/examples/subGroup-markercluster-controlLayers-realworld.388.html)
- [SubGroup with standard L.Control.Layers to display Nested Groups](https://ghybs.github.io/Leaflet.FeatureGroup.SubGroup/examples/subGroup-controlLayers-nestedGroups.html)


text:
Simple Python Neural Network library

  [![Status](https://img.shields.io/badge/status-active-success.svg)]()
  [![GitHub Issues](https://img.shields.io/github/issues/jackroi/NeuralNetwork-python.svg)](https://github.com/jackroi/NeuralNetwork-python/issues)
  [![GitHub Pull Requests](https://img.shields.io/github/issues-pr/jackroi/NeuralNetwork-python.svg)](https://github.com/jackroi/NeuralNetwork-python/pulls)
  [![License](https://img.shields.io/badge/license-MIT-blue.svg)](/LICENSE)

---

 Simple neural network library written in Python using object oriented programming paradigm.

## 📝 Table of Contents
- [About](#about)
- [Getting Started](#getting_started)
- [Usage](#usage)
- [Built Using](#built_using)
- [TODO](./TODO.md)
- [Authors](#authors)
- [Acknowledgments](#acknowledgement)

## 🧐 About
A simple neural network library built for learning purposes. The library is written in Python using object oriented programming paradigm.

## 🏁 Getting Started
These instructions will get you a copy of the project up and running on your local machine for development and testing purposes.

### Prerequisites
You should have a working Python development enviroment (follow [this](https://docs.python-guide.org/starting/installation/))

## 🎈 Usage
The usage of the library is simple, all the code is well documented and there is an [example](#) that solves the XOR problem.

## ⛏ Built Using
- [Python](https://www.python.org/) - Programming language

## ✍ Authors
- [@jackroi](https://github.com/jackroi) - Python implementation

See also the list of [contributors](https://github.com/jackroi/NeuralNetwork-python/contributors) who participated in this project.

## 🎉 Acknowledgements
- [@shiffman](https://github.com/shiffman) Javascript implementation (see [here](https://github.com/CodingTrain/Toy-Neural-Network-JS))

## See Also
- [F# version](https://github.com/jackroi/NeuralNetwork-fsharp) built using functional programming paradigm.

repository: jackroi/NeuralNetwork-python

repo_name: jackroi/NeuralNetwork-python


text:
## Developing

### Setup

First, set up your development environment using the same instructions on the [Readme](README.md).

### Testing

Flasher.js uses mocha for running tests. You can run them with:

```
npm test
```

## Submitting Pull Requests

**Please follow these basic steps to simplify pull request reviews.**

* Please be sure your fork has the latest pull from master
* Run ```npm install``` to make sure your development dependencies are up-to-date
* Please ensure the test suite passes before submitting a PR
* If you've added new functionality, *please include tests* which validate its behaviour
* Make reference to possible [issues](https://github.com/thingssdk/flasher.js/issues) on your PR comment

## Submitting bug reports

* Please detail the affected board (e.g. Adafruit Huzzah Feather), firmware/binary name and version, and operating system(s)
* Please be sure to state which version of node **and** npm you're using


text:
---
title: "Evolving the CLS metric"
subhead: "Plans for improving the CLS metric to be more fair to long-lived pages."
description: "Plans for improving the CLS metric to be more fair to long-lived pages."
authors:
  - anniesullie
  - hbsong
date: 2021-04-07
hero: image/admin/JSBg0yF1fatrTDQSKiTW.webp
alt: An example windowing approach for measuring layout shift.
tags:
  - blog
  - performance
  - web-vitals
---

{% Banner 'info', 'body' %}
  **Jun 2, 2021:** The update to CLS described in this
  post is now available across Chrome's web tooling surfaces. See [Evolving
  Cumulative Layout Shift in web tooling](/cls-web-tooling/) for details.
{% endBanner %}

We (the Chrome Speed Metrics Team) recently outlined our initial research into
[options for making the CLS metric more fair to pages that are open for a long
time](/better-layout-shift-metric/). We've received a lot of very
helpful feedback and after completing the large-scale analysis, we've finalized
the change we plan to make to the metric: **maximum session window with 1 second
gap, capped at 5 seconds**.

Read on for the details!

## How did we evaluate the options?

We reviewed all the feedback received from the developer community and took it
into account.

We also implemented the [top
options](/better-layout-shift-metric/#best-strategies) in Chrome
and did a large-scale analysis of the metrics over millions of web pages. We
checked what types of sites each option improved, and how the options compared,
especially looking into the sites which were scored differently by different
options. Overall, we found that:

* **All** the options reduced the correlation between time spent on page and
  layout shift score.
* **None** of the options resulted in a worse score for any page. So there is no
  need to be concerned that this change will worsen the scores for your site.

## Decision points

### Why a session window?

In our [earlier post](/better-layout-shift-metric/), we covered
[a few different windowing
strategies](/better-layout-shift-metric/#windowing-strategies)
for grouping together layout shifts while ensuring the score doesn't grow
unbounded. The feedback we received from developers overwhelmingly favored the
session window strategy because it groups the layout shifts together most
intuitively.

To review session windows, here's an example:

<figure class="w-figure">
  <video controls autoplay loop muted class="w-screenshot">
    <source src="https://storage.googleapis.com/web-dev-assets/better-layout-shift-metric/session-window.webm" type="video/webm">
    <source src="https://storage.googleapis.com/web-dev-assets/better-layout-shift-metric/session-window.mp4" type="video/mp4">
  </video>
  <figcaption class="w-figcaption">
    Example of a session window.
  </figcaption>
</figure>

In the example above, many layout shifts occur over time as the user views the
page. Each is represented by a blue bar. You'll notice above that the blue bars
have different heights; those represent the [score](/cls/#layout-shift-score) of
each individual layout shift. A session window starts with the first layout shift
and continues to expand until there is a gap with no layout shifts. When the next
layout shift occurs, a new session window starts. Since there are three gaps with
no layout shifts, there are three session windows in the example. Similar to the
current definition of CLS, the scores of each shift are added up, so that each
window's score is the sum of its individual layout shifts.

Based on the [initial
research](/better-layout-shift-metric/#best-strategies), we chose
a 1 second gap between session windows, and that gap worked well in our
large-scale analysis. So the "Session Gap" shown in the example above is 1
second.

### Why the maximum session window?

We narrowed the [summarization
strategies](/better-layout-shift-metric/#summarization) down to
two options in our initial research:

* The **average** score of all the session windows, for very large session
  windows (uncapped windows with 5 second gaps between them).
* The **maximum** score of all the session windows, for smaller session windows
  (capped at 5 seconds, with 1 second gaps between them).

After the initial research, we added each metric to Chrome so that we could do a
large-scale analysis over millions of URLs. In the large-scale analysis, we
found a lot of URLs with layout shift patterns like this:

{% Img src="image/MZfwZ8oVW8U6tzo5CXffcER0jR83/bW3lHZmss3cqGayZsq4P.png",
alt="Example of a small layout shift pulling down the average", width="800",
height="550" %}

On the bottom right, you can see there is only a single, tiny layout shift in
Session Window 2, giving it a very low score. That means that the average score
is pretty low. But what if the developer fixes that tiny layout shift? Then the
score is calculated just on Session Window 1, which means that the page's score
*nearly doubles*. It would be really confusing and discouraging to developers
to improve their layout shifts only to find that the score got worse. And
removing this small layout shift is obviously slightly better for the user
experience, so it shouldn't worsen the score.

Because of this problem with averages, we decided to move forward with the
smaller, capped, maximum windows. So in the example above, Session Window 2
would be ignored and only the sum of the layout shifts in Session Window 1 would
be reported.

### Why 5 seconds?

We evaluated multiple window sizes and found two things:

* For short windows, slower page loads and slower responses to user interactions
  could break layout shifts into multiple windows and improve the score. We
  wanted to keep the window large enough so it doesn't reward slowdowns!
* There are some pages with a continual stream of small layout shifts. For
  example, a sports score page that shifts a bit with each score update. These
  shifts are annoying, but they don't get more annoying as time passes. So we
  wanted to ensure that the window was capped for these types of layout shifts.

With these two things in mind, comparing a variety of window sizes on many
real-world web pages, we concluded that 5 seconds would be a good limit to the
window size.

## How will this affect my page's CLS score?

Since this update caps the CLS of a page, **no page will have a worse score**
as a result of this change.

And based on our analysis, **55% of origins will not see a change in CLS at all
at the 75th percentile**. This is because their pages either do not currently
have any layout shifts or the shifts they do have are already confined to a
single session window.

**The rest of the origins will see improved scores at the 75th percentile with
this change.** Most will only see a slight improvement, but about 3% will see
their scores improve from having a "needs improvement" or "poor" rating to
having a "good" rating. These pages tend to use infinite scrollers or have many
slow UI updates, as described in our [earlier
post](/better-layout-shift-metric/).

## How can I try it out?

We'll be updating our tools to use the new metric definition soon! Until then,
you can try out the updated version of CLS on any site using the [example
JavaScript
implementations](https://github.com/mmocny/web-vitals/wiki/Snippets-for-LSN-using-PerformanceObserver)
or the [fork of the Web Vitals
extension](https://github.com/mmocny/web-vitals-extension/tree/experimental-ls).

Thanks to everyone who took the time to read the previous post and give their
feedback!


text:
# AKStandard Item Description
## Rendering Mode
* Opaque - for drawing objects that are completely opaque.
* Cutout - For drawing objects that are clearly transparent or not transparent. Ideal for cutting out.
* Fade - for drawing transparent objects. Transparent - for drawing transparent objects, including reflections.
* Transparent - for drawing transparent objects. Reflection and other reflections are not transparent.
## Main Map
* Main - the appearance settings of the object's surface.
    * Albedo - the basic appearance of the object. Specify by textures and colors.
    * Normal Map - a pseudo representation of how the object's surface will be illuminated based on the texture. You can adjust the intensity with the slider.
    * Hight Map - Pseudo-texture-based shading of the object's surface with unevenness. The intensity can be adjusted with the slider.
    * Occlusion - The shadowing of the object's surface by light is based on the texture. The intensity can be adjusted with the slider.
* Emission - set the emission of the object's surface.
    * Color - color of the emission with texture or color. The Intensity of the color palette allows you to adjust the intensity.
    * Global Illumination - set the impact of the luminescence on the surroundings. This setting only has an effect on light baking.
        * Realtime - luminescence is used to calculate realtime peripheral lighting; it will allow you to light objects that are not set to Static.
        * Baked - the glow is baked into the surrounding Static objects during light baking. All other objects will only be illuminated by the LightProbe setting.
* Reflection - reflections and reflections of the object's surface.
    * Metallic - sets how metallic the object's surface will be in reflection. Textures and sliders allow you to set the intensity.
    * Smoothness - set how smooth the surface of the object is. Textures and sliders allow you to set the intensity. See also: * Source - This lets you set the intensity of the texture and slider.
    * Source - sets the source of the texture reference from which the smoothness is derived.
        * Albedo Alpha - Uses the Alpha value of the Albedo texture.
        * Metallic Alpha - uses the Alpha value of the Metallic texture.
        * Roughness Map - uses the texture specified for Smoothness.
* This is reflected in Albedo and Emission textures.
## Secondary Map
* Detail - the second setting of the object's appearance. It is mainly used to represent the detail of the character's skin.
    * Detail Mask - the area where the detail is displayed is controlled by the mask texture.
    * Detail Albedo - This is the texture that displays the detail.
    * Detail Normal - A normal map for the detail. The intensity is specified as a number instead of a slider.
    * Tilling Offset - This is where you can set up the repetitive display of the detail, etc.
    * The UV Set - the UV map that will determine where the detail will be displayed.
## Options
* Forward Rendering Options - setting the object's surface drawing options.
    * Specular Highlights - Whether or not to use specular reflection highlights.
    * Reflection - whether or not to use reflection reflections.
* Rendering Options - set the general drawing options.
    * Culling Mask - The display settings for the front and back of the object.
        * OFF - draws both the front and back sides of the object.
        * Front - draw only the back side.
        * Back - draw only the front side.
    * Render Queue - set up the order of drawing.
* Advanced Options
    * Enable GPU Instancing - ability to draw identical meshes together. [Details] (https://docs.unity3d.com/ja/2018.4/Manual/GPUInstancing.html)
    * Doubel Sided Global Illumination - uses both sides of an object when calculating ambient light.

Translated with www.DeepL.com/Translator (free version)


text:
# Beyaz Dag

It is not far from Navekat and Suyab to the lake they call the Eye of the World. But the visions you sought there carried you much farther,
across mountains, deserts, marshes, across the Mother River to the lonely Mount Beyaz. Here, perhaps, you can convince the merciful goddess
who lives above the clouds to save your people from the plague.

Beyaz Dag towers solitary above the deserts. No rival peak dares rear itself nearby, though a desultory range of hills stretches southwards. The mountain’s western slopes fall off steeply into a deep blue lake; north lie the marshes that fringe the Mother River.

You never mastered sword and lance, like your brothers, but can shoot, ride, and wrestle as well as any of them.

Beyaz Dag teems with life: hyenas and gazelles in the desert scrub, deer, wolves, bear in the forests. Travelers you met on the Northern Road tell of other, darker things here: ruins, abandoned quarries, sunken grottoes...

Now you're almost through the marshes; the mountain rises to the southwest.

* Source at https://github.com/Naburimannu/beyaz-dag
* Engine at https://github.com/Naburimannu/libtcodpy-tutorial

Originally based on Jotaf's Python roguelike tutorial for libtcod.

## Combat Model

If you are unfortunate enough to get into a fight, you'll see messages in your log like:

> Player (40) attacks hyena (10) for 4 wounds.
> Hyena (16) attacks player (20) but misses.

The numbers in parentheses are the participants' effective attack and defense skills. Equal skills provide a 50% chance of success; a 2:1 ratio in skills provides a 75% chance of success, a 3:1 ratio an 85% chance of success. All attack success chances depend on the weapon used; melee defense depends on shield skill if a shield is equipped, plus half of weapon skill. Missile defense depends on the distance between the combatants, plus half of shield skill if a shield is equipped.

All effective skills are reduced by: exhaustion, wounds, bleeding, intoxication.
Exhaustion accumulates as you walk, climb, or fight; it can be reduced by food and drink.
Wounds accumulate from combat; if wounds ever exceed your maximum hit points (36), you fall unconscious - and since you have no companions it's assumed you die.
Bleeding sometimes occurs during combat; once you're bleeding, you'll continuously lose hit points until they reach 0 and you die. First aid skill and the application of bandages are necessary to stop bleeding.
Intoxication is a side effect of some beverages or other events in the world.

Based on Wizard's Crown and related games published for personal computers in the mid-1980s.

## Strategy Notes

* Fighting is dangerous and rarely beneficial.
** Archery is deadly, but arrows are in short supply.
** If you get out of sight of your enemies, they're not likely to pursue very far.
* Melee weapon skills also influence defense.
** To be effective, have a skill of at least 40 in any weapon you use.
* Choices are hard.
** Fighting the wrong enemy without a shield (and shield skill) may be fatal.
** Fighting the wrong enemy in melee instead of with a bow may be fatal.
** Switching between bow and shield at a bad time may be fatal.

## Spoilers

* Grinding can yield more than 400 skill points, but a successful playthrough may only need half that.
* AI pathing is really, really poor; (in the current build) you are expected to exploit this.

repository: Naburimannu/beyaz-dag

repo_name: Naburimannu/beyaz-dag


text:
[VIR1021I VIRARBO type RECORD name ADDED/UPDATED/DELETED BY USER userid AT TERMINAL termid](https://virtel.readthedocs.io/en/latest/manuals/virtel/Virtel459MG/messages.html?highlight=VIR1021I#VIR1021I)

`Module`
- VIR0010

`Meaning`
- User userid at terminal termid has added, updated, or deleted a record in the VIRTEL configuration file. type is the record type (LINE, TERMINAL, SERVER, ...) and name is the entity name.

`Action`
- None.

repository: olepicard/tldrZ

repo_name: olepicard/tldrZ


text:
---
layout: post
title:  "CSS Chevron bar"
subtitle:
date:   2016-06-10 10:00:13
background: '/img/posts/css.jpg'
tags: css sass ui
---
I’ve been messing around with a ChevronBar to display progress through a workflow or wizard.

The first version was based on CSS and sprites, but I want a way of easily changing the colours of the steps. I based the following on https://github.com/twslankard/css-chevron-bar.

![Example of chevron bars](/img/posts/sass-chevronbar-test.png)

There is a bit of messing around when the font changes , but it’s a good start 🙂

[Play with this gist on SassMeister](http://sassmeister.com/gist/21b904ec1eb2c6287d1c18ea61ecd30b).


text:
# Test Page

You can use this by downloading it from your *machine*

wget https://github.com/fadsel/hello.git

Unzip it to your folder

unzip hello

Enjoy

repository: fadsel/hello

repo_name: fadsel/hello