text:
# blockly-samples [![Built on Blockly](https://tinyurl.com/built-on-blockly)](https://github.com/google/blockly)

Sample projects showing how to integrate Blockly into your project.
- [``blockly-requirejs-sample``](blockly-requirejs/README.md): Loads RequireJS from a CDN and loads Blockly using ``AMD``.
- [``blockly-umd-sample``](blockly-umd/README.md): Loads the UMD build of Blockly (``blockly.min.js``), both from node_modules and from Unpkg.
- [``blockly-webpack-sample``](blockly-webpack/README.md): Using Blockly in Webpack.
- [``blockly-node-sample``](blockly-node/README.md): Using Blockly in Node.js, loaded using require (``CommonJS``).
- [``blockly-angular-sample``](blockly-angular/README.md): Blockly in an Angular project, defines an Angular Blockly Component.
- [``blockly-react-sample``](blockly-react/README.md): Blockly in a React project, defines a React Blockly Component.
- [``blockly-svelte-sample``](blockly-svelte/README.md): Blockly in a Svelte project, defines a Svelte Blockly Component.
- [``blockly-vue-sample``](blockly-vue/README.md): Blockly in a Vue project, defines a Vue Blockly Component.

## Running the samples

In order to run each of the samples, cd into each sample directoy and run:
```bash
npm install
```

You can then run ``npm run start`` to start a web server.

All samples are configured to use port ``3000``<br/>
so open [http://localhost:3000](http://localhost:3000) to view each sample in the browser.

## Support

Blockly has an active [developer forum](https://groups.google.com/forum/#!forum/blockly). Please drop by and say hello. Show us your prototypes early; collectively we have a lot of experience and can offer hints which will save you time. We actively monitor the forums and typically respond to questions within 2 working days.

## Get Blockly

You can install the ``blockly`` package on [npm](https://www.npmjs.com/package/blockly).

```
npm install blockly
```

## Importing Blockly

When you import Blockly with ``import * as Blockly from 'blockly';`` you'll get the default modules:
Blockly core, Blockly built-in blocks, the JavaScript generator and the English lang files.

If you need more flexibility, you'll want to define your imports more carefully:

#### Blockly Core

```js
import * as Blockly from 'blockly/core';
```

#### Blockly built in blocks

```js
import 'blockly/blocks';
```

#### Blockly Generators
If your application needs to generate code from the Blockly blocks, you'll want to include a generator.

```js
import 'blockly/python';
```
to include the Python generator, you can also import ``blockly/javascript``, ``blockly/php``, ``blockly/dart`` and ``blockly/lua``.

#### Blockly Languages

```js
import * as Fr from 'blockly/msg/fr';
Blockly.setLocale(Fr);
```

To import the French lang files. Once you've imported the specific lang module, you'll also want to set the locale in Blockly.

For a full list of supported Blockly locales, see: [https://github.com/google/blockly/tree/master/msg/js](https://github.com/google/blockly/tree/master/msg/js)

## License

Apache 2.0

repository: navilperez/blockly-samples

repo_name: navilperez/blockly-samples


text:
### Agent of search of subdividing of the specified entity

The task of this agent is to search for subdividing of a given entity.

One of subdividing of concept **set**:

![](content/goal.png)

#### Work example

Search for subdividing of **set** concept.

**Request:**
![](content/request.png)

**Response:**
![](content/response.png)

license: MIT

repository: ostis-apps/ostis-example-app

extension: md

gha_license_id: MIT

license_type: permissive

repo_name: ostis-apps/ostis-example-app


text:
# MHSampling

An introduction to Bayesian parameter estimation and posterior sampling techniques.

To follow along with the notebooks, clone this repository using the following command:

`git clone https://github.com/rmorgan10/MHSampling.git`

All materials are from the [LSSTC Data Science Fellowship Program](https://github.com/LSSTC-DSFP/LSSTC-DSFP-Sessions)

branch_name: refs/heads/master


text:
# Configuration

- [Addon Configuration](#addon)
- [Basic Configuration](#basic)
- [Extra Configuration](#extra)
- [Option Handlers](#handlers)

Below is the full configuration available with defaults.

    protected $fields = [
        "example" => [
            "type"   => "anomaly.field_type.country",
            "config" => [
                "default_value" => null,
                "top_options"   => null,
                "handler"       => "Anomaly\CountryFieldType\Handler\DefaultHandler@handle"
            ]
        ]
    ];

## Addon Configuration

The country dropdown options are controlled by the country field type's `countries.php` configuration file by default.

You can override these options by overloading the configuration file with a config file of your own at `/resources/{reference}/config/addons/country-field_type/countries.php`

Contribute: If you have options to add or have found an error, submit a pull request to https://github.com/anomalylabs/country-field_type

## Basic Configuration

### Default Value

    "default_type" => "US"

The `default_value` is a core option. This field type accepts any available country from the options.

### Top Options

    "top_options" => ["US", "CA"]

Specify the country options that are pushed to the top of the dropdown. This is helps prevent users from having to scroll through less common options.

## Option Handlers

Option handlers are responsible for setting the available country options on the field type. You can define your own option handler to add your own logic to available dropdown options.

### Defining Custom Handlers

Custom handlers can be defined as a callable string.

    "handler" => "App/Example/MyCountries@handle"

You can also define custom handlers as a closure.

Remember: Closures can not be stored in the database so you need to define closures in the form builder.

    protected $fields = [
        "example" => [
            "config" => [
                "handler" => function (CountryFieldType $fieldType) {
                    $fieldtype->setOptions(
                        [
                            "US" => "anomaly.field_type.country::country.us",
                            "CA" => "anomaly.field_type.country::country.ca"
                        ]
                    );
                }
            ]
        ]
    ];

### Building Custom Handlers

Building custom option handlers could not be easier. Simply create the class with the method you defined in the config option.

    "handler" => "App/Example/MyCountries@handle"

The callable string is called via Laravel's service container. The `FieldType $fieldType` is passed as an argument.

Note: Because handlers are called through Laravel's service container, you can automatically inject dependencies into the construct and method.

    class MyCountries
    {
        public function handle(CountryFieldType $fieldType)
        {
            $fieldtype->setOptions(
                [
                    "foo" => "FOO",
                    "bar" => "BAR"
                ]
            );
        }
    }

gha_language: PHP


text:
---
title: Configuring Existing Telerik Projects
page_title: Setting Up Existing Telerik Projects - Visual Studio Integration
description: Learn how to configure your existing Telerik UI for Blazor application with a few clicks by using the Project Configuration Wizard supporting the Visual Studio (VS) extensions.
slug: getting-started-vs-integration-configure-project
position: 4
---

# Configuring Existing Telerik UI for Blazor Projects

This article demonstrates how to configure an existing Telerik UI for Blazor application by using the Project Configuration Wizard. The wizard comes with the Telerik UI for Blazor VS extensions and helps you to modify settings like the visual theme, CDN utilization, and configuration for content localizing in existing projects.

To use the wizard, your project must be already [configured as a Telerik UI for Blazor application]({%slug getting-started-vs-integration-convert-project%}) and be able to use the Telerik UI components.

To open the Project Configuration Wizard, click **Extensions** > **Telerik** > **Telerik UI for Blazor** > **Configure Project**.

![Telerik UI for Blazor Visual Studio 2022 Extensions menu](../vs-integration/images/configure-project-open.png)

The configuration wizard handles the following tasks:
- [Theme selection](#theme-selection)
- [Project settings configuration](#project-settings)

## Theme Selection

The **Theme Selection** page enables you to change the [visual theme](/blazor-ui/styling-and-themes/overview#built-in-themes) of your Telerik UI for Blazor application.

![Theme Selection menu in the Project Configuration Wizard](../vs-integration/images/configure-theme.png)

After selecting the desired theme, click **Next** to navigate to the [Project Settings](#project-settings) page.

## Project Settings

The **Project Settings** page allows you to enable or disable the [Telerik UI CDN support](/blazor-ui/getting-started/what-you-need#using-cdn).

![Project Settings dialog in the Project Configuration Wizard](../vs-integration/images/configure-settings.png)

## See Also

* [Visual Studio Integration for Telerik UI for Blazor Overview]({% slug getting-started-vs-integration-overview %})
* [Converting to Telerik Projects]({% slug getting-started-vs-integration-convert-project %})

repository: telerik/blazor-docs

gha_language: JavaScript

repo_name: telerik/blazor-docs


text:
# Kubernetes Ansible AWS EC2

![Kubernetes](script/kubernetes-logo-color.png)
A collection of playbooks for deploying a Kubernetes development cluster onto machines, they are fully automated command to bring up a Kubernetes cluster on VM's or AWS EC2.

Feature list:
- [x] Support Kubernetes v1.19.0+.
- [x] Highly available development Kubernetes cluster.
- [x] Provisioning AWS EC2 Instances
- [x] Kubernetes addons:
  - [x] Helm.
  - [x] Metrics Server.
  - [x] NFS Dynamic Provisioning.
  - [x] Kubernetes Dashboard.
- [x] Support container network:
  - [x] Calico.
  - [x] Flannel.
- [x] Support container runtime:
  - [x] Docker.
  - [x] Containerd.
  - [x] CRI-O.

## Quick Start
In this section you will deploy a cluster via AWS EC2.

Prerequisites:
* For running this ansible role for privisioning and setting up k8s cluster you need: Ubuntu 18.04 or above or RHEL but I have tested on Ubuntu based machine.
* Clone this Repo
* Need to steup Ansible on local machine.

```sh
$ sh py-ansible.sh
[❗Updating & Installing Python Latest Version ]
[❗Installing Ansible ]
[✅ successfully Installed Python3 & Ansible ]
```
* Create AWS IAM User with AdministratorAccess Permissions.
* Add IAM User Access key and Secret key in roles/infra/vars/cred.yml using Ansible Vault by using below command.
 Add your Access key & Secret key in cred.yml ansible vault.

 ```yml
 $ ansible-vault edit roles/infra/vars/cred.yml
 Vault password: 123
 ```
* `roles/infra/vars/cred.yml` ansible vault password was set to `123`
* To view cred using vault
```yml
ansible-vault view cred.yml
Vault password: 123
access_key: **********************
secret_key: **************************
```

### Key Features
Provisioning will create a custom ansible inventory file for setting up k8s cluster.
```ini
$cat /etc/ansible/custom_inv.ini

# This is custom inventory file which will use in setting up k8s cluster
[master]
<IP_ADDRESS> ansible_ssh_private_key_file=/etc/ansible/id_rsa_aws

[worker]
<IP_ADDRESS> ansible_ssh_private_key_file=/etc/ansible/id_rsa_aws

[kube_cluster:children]
master
worker
```

### Variables
AWS EC2 related Variables, located under kubernetes-ansible/roles/infra/vars/main.yml
```yml
# To change region.
ec2:
 region: eu-west-1

# To change Master Instance type
master:
    vm_type: t2.medium

# To change no. of worker nodes and it's types
worker:
    vm_type: t2.micro
    vm_count: 1
```

Set the variables in `group_vars/all.yml` to reflect you need options.
```yml
# overide kubernetes version(default: 1.10.6)
kube_version: v1.20.4

# Supported Network implementation('flannel', 'calico')
network: calico

# Supported container_runtime: [ docker containerd crio]
container_runtime: crio

# Additional feature to install
additional_features:
  helm: false
  nfs_dynamic: true
  metric_server: true

# Dashboard
enable_dashboard: yes
need_to_save_dashboard_token: yes

# NFS Directory
nfs:
  dir: /nfs-private
```
### Provision AWS EC2 and deploy a Kubernetes cluster
If everything is ready, just run `./aws-k8s.sh` to provision ec2 and deploy the cluster on it:
```sh
$ sh aws-k8s.sh
Vault password: 123
```

![alt tag](https://github.com/khann-adill/kubernetes-ansible/blob/main/script/ansi%20status%20k8s.PNG)

## Verify cluster
Verify that you have deployed the cluster, check the cluster as following commands:
```yml
$ kubectl get nodes -o wide

NAME      STATUS   ROLES                  AGE     VERSION   INTERNAL-IP    OS-IMAGE           KERNEL-VERSION   CONTAINER-RUNTIME
kmaster   Ready    control-plane,master   3h28m   v1.20.4   <IP_ADDRESS>  Ubuntu 20.04.2 LTS   5.4.0-1038-aws   cri-o://1.20.1
kworker   Ready    <none>                 3h25m   v1.20.4   <IP_ADDRESS> Ubuntu 20.04.2 LTS   5.4.0-1038-aws   cri-o://1.20.1
...
```
## Show your support

Give a ⭐ if this project helped you!

## Author

👤 **Adil Abdullah Khan**

[<img align="left" alt="LinkedIn" width="22px"<EMAIL_ADDRESS>/>][linkedin]
[<img align="left" alt="facebook" width="22px"<EMAIL_ADDRESS>/>][facebook]
[<img align="left" alt="Twitter" width="22px"<EMAIL_ADDRESS>/>][twitter]
[<img align="left" alt="Instagram" width="22px"<EMAIL_ADDRESS>/>][instagram]

[facebook]: https://www.facebook.com/adilabdullah.khan.393
[twitter]: https://twitter.com/adilkhan220496
[instagram]: https://www.instagram.com/khann_adill/
[linkedin]: https://www.linkedin.com/in/adil-abdullah-khan-682075140/

license: Unlicense

branch_name: refs/heads/main


text:
Cell Society
Design Plan
===========

## Introduction

### Problem Definition
Create a versatile program to model any 2 dimensional cellular automata simulation. The cells in the simulation must be able to switch between multiple states based off of the state of other cells around them, and there must be a "grid" visualization accompanying the simulation.
### Primary Design Goals
Build a flexible simulation framework that can be used to simulate several different rule sets including state reliance on different sets of cells, different starting configurations, and different cell types.
### Primary Architecture
We would like to keep components as separate as possible. If a class doesn't
need to know, it should not know, and should definitely not be able to modify priviledged information.

There should be a ruleset, which is open to be extended for a variety of rulesets. The ruleset should communicate the application of rules (resulting States) to particular cells, but should not expose the actual rules where possible. A Rulekeeper can hold the possible rulesets.

A cell should be able to represent a variety of different cell types, and have a standard communication contract (regardless of the exact cell type) with others to calculate state changes or to share state information. It's internal information should be private, and others should not be able to modify it.

The GUI is in charge of knowing what to display, and handling user input. Any information not directly tied to these goals should not be included here. It should be able to display a variety of different game types, or support varying other features/parameters.

## Overview

### Verbal Map of Design

#### Cell
The first major class we decided to create was a Cell class, which will hold a State (possibly the current and future state), its own position, and is aware of its "neighboring" cells (aka neighborhood), and should have a way to update itself depending on the state of its neighborhood. A Cell should know its own present and future state, which it can communicate to others. It should remember its own neighborhood. It should communicate with a ruleSet to determine its next state, given its neighborhood.
#### Grid
The Grid will be the structure that holds the cells. This object will allow access to all the cells in an organized manner. The Grid should communicate with the GUI, and should know how to tell its cells to update.
#### SimulationCoordinator
The SimulationCoordinator's primary job is to make sure the other pieces execute at the right time, and in the right order. It takes in data from the GUIManager based on user input. It tells the Grid when to update cells.
#### Neighborhood
A Neighborhood represents the group of relevant information from cells that affect a particular cell's next State. Each Cell has its own Neighborhood. This neighborhood should be determined upon initialization.
#### State
The State class enumerates the allowed states of cells.
#### Configuration.XMLReader
The Configuration.XMLReader class will read the XML file and create a RuleSet object based off of which simulation is called to be run in the file. It will pass the allowed states to the State class, the initial configuration and states of the Cells to the SimulationCoordinator class, and pass the grid size and game information to the GUIManager class.
#### RuleSet
The RuleSet class will be abstract, with subclasses representing each of the games. It will have information such as how the State of a Cell is calculated.
#### GUIManager
The final class is the GUIManager. This will display the current state of all of the cells and update with every step run in simulation.
### RuleKeeper
Holds several RuleSets so that we can switch between the games.

### Visual Map of Design
![](CellSociety.png)

## User Interface
* Overall Appearance of User Interface:
The user interface will be a single JavaFX window containing the grid of cells, a legend that defines which cell colors correspond to which simulation states, a "Start" button, "Stop" button, and simulation type selection dropdown menu in case the XML file contains multiple types.

* Description of User Interaction:
In addition to buttons and dropdown menus for controlling the simulation, the user will be able to press Enter to start a simulation, Escape to stop a simulation, and Space to pause a simulation.

  Errors and status messages will be displayed to the user in the Java console. Such error methods will include: bad XML file, file not found, and initial states not allowed.

* Drawing of Basic Interface:
![](mockGUI.png)

## Design Details
### Description of Program Components
#### Cell
The Cell object will have instance variables that record what its current state is and will also be able to hold what its next state is, after the updated state is calculated using all of its neighboring cells' current states. It will also be able to tell the GUIManager if it has been changed or not, so the GUIManager knows whether or not to update its visualization. Each cell will also know its location in the grid, corresponding to a row and column number.
* Methods
    * private void setNextState();
    * public State getCurrentState();
    * public State getNextState();
    * private Neighborhood getNeighbors();
    * public boolean getChanged();
* Variables
    * private boolean hasChanged;
    * private Position myPosition;
    * private Neighborhood myNeighborhood;
    * private State myCurrentState;
    * private State myNextState;

#### Grid
The Grid will be an object containing all Cell objects that are currently involved in the simulation. This will allow us to update all of the cells and update the GUI only once per step instead of once for every cell that changes within a step.
* Methods
    * private void createCells(int[][] cellLocations);
    * public void updateGrid();
    * public int getWidth();
    * public int getHeight();
* Variables
    * private int myWidth;
    * private int myHeight;
    * private List\<List\<Cell>> myCells;

#### GUIManager
The GUIManager will be in charge of the visualization of the state of all of the cells in the created grid. It will be updated every step that occurs in a simulation, and will be able to check if a cell was updated in the last calculation and if it was, change the visual state of the block.
* Methods
    * private void initializeGUI(Scene scene, Grid grid, List\<State>);
    * public void updateGUI(Grid grid);
    * private void updateCellColor(int row, int col);
    * public void keyboardHandler(Keycode k);
    * public void GUIListener();
    * private void drawText(String message);
    * private void drawLegend(List\<State>);
* Variables
    * private enum stateColors;
    * private Button myStart;
    * private Button myStop;
    * private ComboBox myRuleSelector;
    * private Stage myStage;
    * private Scene myScene;
    * private GridPane myGridPane;

#### SimulationCoordinator
The SimulationCoordinator class will be in charge of running the game, stepping through the simulation and calling for updates in each step. It will create the Grid which creates and holds the cells, and create the scene that will be used to visualize the simulation. It will also house the main method that that enables the simulation to run.
* Methods
    * private void start();
    * private void stop();
    * private void advance();
    * private void reset();
    * private void step(); //controls real-time application operations
    *

#### Configuration.XMLReader
The Configuration.XMLReader will read the XML file and pass relevant information to the SimulationCoordinator. The SimulationCoordinator will then pass allowed states to State, grid size and game info to the GUIManager, and the simulation parameters to RuleKeeper.
* Methods
    * private void readXML(File XMLfile);
    * public String[] getAllowedStates();
    * public int[][] getInitialState();
    * public int getGridSize();
    * public String getGameInfo();
    * public String getSimParameters();

#### State
State is an enum type, which will enumerate what states a cell is allowed to have, in a very readable manner.

#### RuleSet
RuleSet will be an abstract class that defines a game. It will have access to which neighboring cells the updated state of the current cell relies on, and the formula used to calculate the next state. The RuleSet class will be highly versatile, as each new game that we want to create can be created through the use of a subclass and no other major changes to the code.
* Methods
    * public void update(Grid testGrid);
    * public void setParameters(); //depends on subclass simulation

#### RuleKeeper
RuleKeeper will have multiple RuleSets, so when the kind of simulation is changed the program can seamlessly switch between the desired games.
* Methods
    * private void updateType(RuleSet simType);

### Use Cases
1. Apply the rules to a middle cell: to set the state of a middle cell, the cell (which knows all of its neighbors) will be passed to the update function of a RuleSet object. It's next state will be calculated based off of the neighboring cells' states, and put into the cell object's nextState variable.
2. Apply the rules to an edge cell: We will have to do some experimenting with edge cells for each of the game. Several ideas that we have include keeping edge cells static, treating all "neighboring" cells that would be out of bounds of the grid as a single state, or having the edge cells rely on the opposite sides edge, as if the grid wrapped around like a cylinder.
3. Move to the next generation: The simulation will move to the next generation once all of the cells have been updated, and that update has been passed to the GUI. Basically, each time the step function is called in simulation a new generation will be calculated and updated.
4. Set a simulation parameter: The simulation parameters will all be held in the RuleSet object. We will have paramaters such as probability, depending on the game, that can be passed into the RuleSet object to customize its update method.
5. Switch simulations: We will be able to switch simulations by taking the GUI input simulation from a dropdown, and running the simulation with the RuleSet of that type.

## Design Considerations
### Treatment of Edge Cells
We are still not entirely certain as to how edge cells should be treated in the simulation.
Because they lack the common 9 neighboring cells that all other cells have,
it is difficult to say how should be updated, or if they should be updated at all.
We cannot say for certain whether they should be static, dependent on only their 3 or 6 surrounding cells,
or if they should be dependent on the opposite edge as if the simulation wrapped around.
There are many options available. We will seek to create our Cell class in a flexible manner that avoids
"special hardcoding" for edge cells wherever possible.

### Location of the main function
We ended up deciding to put the main function in SimulationCoordinator instead of GUIManager because we realized that we can pass the stage to the GUIManager a single time at the beginning, and still manage to start and step through the SimulationCoordinator.

### Where to create cells
We decided to create the cells in Grid to stop SimulationCoordinator from becoming too cluttered. We wanted SimulationCoordinator to be more of an intermediary between the classes, and it had begun to contain too much information and take on too much of the responsibility of our program so we shifted the creation of cells to the grid class.

## Team Responsibilities

### Lucas
Will primarily handle the simulation logic. This involves handling most of the work with the cells, rulesets, rulekeepers, simulationCoordinators, and grids. As a secondary role, the simulation will bleed into the other two members roles, particularly where communications occur.

### Ian
Will primarily handle the configuration in the project, handling the parsing of the XML file and connecting it to different aspects of the simulation with a focus on veratility to be able to account for the creation of as many different simulation variants as possible. Will be secondarily a part of the simulation, especially linking the configuration with the simulation.

### Harry
Will primarily handle the front-end visualization and user interface aspects of the project, including GUI implementation and user input handling. Secondarily, will handle relevant areas of the simulation classes that impact the GUI.


text:
---
title: ESX.Game.GetPedMugshot
category: ES Extended
order: 6
---

![screenshot](https://i.imgur.com/OV72S12.jpg)

```lua
local mugshot, mugshotStr = ESX.Game.GetPedMugshot(ped)
```

You can do it like in the following example with ESX.ShowAdvancedNotification:

```
Be sure to use UnregisterPedheadshot(mugshot) after using it,
because the game only allows you 34 mugshot and you won't be allowed to use
mugshot once this limit is reached if you don't unregister it.
```

```lua
ESX = nil

Citizen.CreateThread(function()

	while ESX == nil do
		TriggerEvent('esx:getSharedObject', function(obj) ESX = obj end)
		Citizen.Wait(0)
	end

	while true do
		Citizen.Wait(10)
		if IsControlJustReleased(0, 22) then -- Spacebar key
		    notification('Hello')
		end
	end
end)

function notification(msg)
	local mugshot, mugshotStr = ESX.Game.GetPedMugshot(GetPlayerPed(-1))
	ESX.ShowAdvancedNotification('Test', 'Testing!', msg, mugshotStr, 1)
	UnregisterPedheadshot(mugshot)
end
```
### Related
- [ESX.ShowAdvancedNotification](../esx.showadvancednotification)


text:
# @bzelip/basscss7.1.1

Distribution of [basscss<EMAIL_ADDRESS>as a dependency-free npm package that indicates its main file in package.json.

## Installation

```bash
npm i -S @bzelip/basscss7.1.1
```

## Usage

```css
@import<EMAIL_ADDRESS>```

## Test

Verify that<EMAIL_ADDRESS>is the same as<EMAIL_ADDRESS>
```bash
npm test
```

## Motivation

[Basscss](https://basscss.com/) was amazing when it came out, and inspired much innovation in the CSS world. Its [author](https://jxnblk.com) is a front end and design system hero.

While the project is no longer active and stopped at version 8.x, [version 7.1.1](https://basscss.com/v7/) remains my favorite.

Basscss came out at the time when folks were just starting to stretch the intended use of npm from distributing Node server files to distributing web development tools more broadly, including CSS.

But there weren't many conventions or tools for this shift yet. So single assets in packages like Basscss were awkwardly copied to CSS directories from node_modules/, or imported explicitly from node_modules/.

```css
@import '../node_modules/basscss/css/basscss.min.css';
```

😵

Also, installing<EMAIL_ADDRESS>adds 30 total packages. It's not _that_ big of a deal, especially since they're all small packages. But when working in a build environment like Netlify or GitHub Actions, time is money.

I'd rather publish a fork that ships 5 files total and can be imported using it's package name (using a tool like [postcss-import](https://www.npmjs.com/package/postcss-import)), eg:

```css
@import 'basscss';
```

## Author

Brian Zelip, https://zelip.me

## License

MIT


text:
Sorting and Paging Results
==========================
Using LINQ and N1QL, it's easy to sort and page results.

##Sorting
For LINQ, sorting of results is represented by the orderby clause, which accepts a comma-delimited list of properties to sort by.

	using (var cluster = new Cluster()) {
		using (var bucket = cluster.OpenBucket("beer-sample")) {
			var context = new BucketContext(bucket);

			var query = from contact in context.Query<Contact>()
						orderby contact.LastName, contact.FirstName
						select contact;

			foreach (var doc in query) {
				// do work
				// query will return the contacts sorted by last name, then by first name
			}
		}
	}

To sort in descending order, add the descending keyword to the sort property.

	using (var cluster = new Cluster()) {
		using (var bucket = cluster.OpenBucket("beer-sample")) {
			var context = new BucketContext(bucket);

			var query = from contact in context.Query<Contact>()
						orderby contact.LastName descending, contact.FirstName descending
						select contact;

			foreach (var doc in query) {
				// do work
				// query will return the contacts sorted by last name descending, then by first name descending
			}
		}
	}

##Paging
Paging of data is done using the LINQ Skip and Take functions.  Skip is applied first, and skips a certain number of records in the result set.  Then Take is applied, which limits the maximum number of results which are returned.

When possible, paging using Skip and Take can significantly improve query performance by allowing the query to short-circuit once enough data is available for the result set.

Additionally, Take and Skip should normally be used in conjunction with an orderby clause.  Without sorting the query results become unpredictable.

	using (var cluster = new Cluster()) {
		using (var bucket = cluster.OpenBucket("beer-sample")) {
			var context = new BucketContext(bucket);

			var query = (from contact context.Query<Contact>()
						 orderby contact.LastName, contact.FirstName
						 select contact).Skip(20).Take(10);

			foreach (var doc in query) {
				// do work
				// query will return the contacts sorted by last name, then by first name
				// returning only the 21st through 30th contacts (if any)
			}
		}
	}

**Note:** It is not required to use both Skip and Take, you may use one without the other.

gha_language: C#


text:
HD Wallet Scanner

		Find all used addresses in your Bitcoin HD Wallets bypassing gap limits

HD Wallet Scanner is a utility for resolving an [Account Discovery](https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki#account-discovery) issue when a HD Wallet has more than X (usually 20) unused addresses in a row and a wallet software stops seeing addresses beyond this point.

The utility was made to supplement [One-Time Address](https://github.com/alexk111/One-Time-Address). However it will also be helpful if you encounter the gap limit issue in other circumstances.

## How it works

1. You set an extended public key, a range for address indexes and a starting block for each of your HD Wallets
2. HD Wallet Scanner scans blocks and generates report files with address indexes and input stats in ```output``` directory
3. You use Bitcoin Core + HWI (if you use a hardware wallet) to import child keys derived with the address indexes and then spend unspent outputs

## Prerequisites

To run the application, you will need a synced Bitcoin full node with RPC enabled.

## Installing

```
# clone repo
git clone https://github.com/alexk111/HD-Wallet-Scanner

# navigate to it
cd HD-Wallet-Scanner

# install dependencies
yarn install

# add env variables
cp .env.sample .env

# add wallets config
cp wallets.js.sample wallets.js
```

Edit ```.env```:

- BITCOIND_RPCUSER and BITCOIND_RPCPASSWORD - user/pass to access Bitcoin RPC server
- MAX_ADDRESSES_PER_ITERATION - max number of addresses per a scan iteration (default: 100000)

Edit ```wallets.js```:

- Enter settings for your wallets

## Scanning

```
# running the scanner
yarn start
```

## Using Address Indexes

After the scan completes, you will get two files in ```output``` directory: ```IDS ids{i}-{j} hgt{m}-{n}.json``` and ```INS ids{i}-{j} hgt{m}-{n}.json```. The ```IDS ...``` file only contains the address indexes, whereas the ```INS ...``` file also contains an address, value of a transaction input and a height of a block the transaction is recorded in.

To derive child keys with the collected address indexes and import them into Bitcoin Core wallet use [HWI](https://github.com/bitcoin-core/HWI) if your private keys are stored on a hardware wallet and ```bitcoin-cli```'s [importmulti](https://bitcoin.org/en/developer-reference#importmulti). For more info on how to use Bitcoin Core with HWI check [this guide](https://github.com/bitcoin-core/HWI/blob/master/docs/bitcoin-core-usage.md).

 Note. If you have huge gaps between used addresses, then call ```importmulti``` with keypool range parameter equal to ```n,n``` where ```n``` is an address index, to add only that specific address.

## Backers 💝

[[Become a backer](https://mynode.alexkaul.com/gh-donate)]

[![Backer](https://mynode.alexkaul.com/gh-backer/top/0/avatar/60)](https://mynode.alexkaul.com/gh-backer/top/0/profile)
[![Backer](https://mynode.alexkaul.com/gh-backer/top/1/avatar/60)](https://mynode.alexkaul.com/gh-backer/top/1/profile)
[![Backer](https://mynode.alexkaul.com/gh-backer/top/2/avatar/60)](https://mynode.alexkaul.com/gh-backer/top/2/profile)
[![Backer](https://mynode.alexkaul.com/gh-backer/top/3/avatar/60)](https://mynode.alexkaul.com/gh-backer/top/3/profile)
[![Backer](https://mynode.alexkaul.com/gh-backer/top/4/avatar/60)](https://mynode.alexkaul.com/gh-backer/top/4/profile)
[![Backer](https://mynode.alexkaul.com/gh-backer/top/5/avatar/60)](https://mynode.alexkaul.com/gh-backer/top/5/profile)
[![Backer](https://mynode.alexkaul.com/gh-backer/top/6/avatar/60)](https://mynode.alexkaul.com/gh-backer/top/6/profile)
[![Backer](https://mynode.alexkaul.com/gh-backer/top/7/avatar/60)](https://mynode.alexkaul.com/gh-backer/top/7/profile)
[![Backer](https://mynode.alexkaul.com/gh-backer/top/8/avatar/60)](https://mynode.alexkaul.com/gh-backer/top/8/profile)
[![Backer](https://mynode.alexkaul.com/gh-backer/top/9/avatar/60)](https://mynode.alexkaul.com/gh-backer/top/9/profile)

## License

MIT © Alex Kaul


text:
# wipay NodeJs Wrapper
Wipay payment Integration

The wipay-node library provides convenient access to the wipay API from applications written in server-side JavaScript.

### Documentation
See the [Wipay API docs](https://wipaycaribbean.com).

The package needs to be configured with Production Mode.

###Installation
Install the package with:
```
npm install wipay-node
```
### Include
```javascript
var wipay = require('wipay-node');
```

### Set Mode
```javascript
wipay.ProductionMode(true); // production = true, test = false
```

### APIs Available
* [Create a payment request](#create_payment)

### Create new payment request Using async/await
```javascript

var paymentData = {
    total : "", // "100.00"
	phone : "", // "0123456789"
	email : "", //<EMAIL_ADDRESS>	name : "",  // "name"
	order_id : "", // "12345"
	return_url : "", //"http://localhost:8080/status"
	developer_id : "", // developer_id from account or "1" for sandbox
}

let url = await wipay.create_payment(paymentData);

```
### Test Credit Card
Card Number :<PHONE_NUMBER>111111
Card CVV : 123
Expiry Month : 01
Expiry Year : 25

---
### Submit Queries
You can mail an issue/query at amansharma5@hotmail.com


text:
# Data Formats

The type of files involved in this package can be divided into two categories: input files and output file. The summary of different files are listed as

| Name       | Category           | Extension  | Description |
| ------------- |-------------|:-----:|-------------|
| Kernel matrices    | Input | .csv | Multiple csv files that contain the kernel distance matrices (variance components) which is calculated from the microbiome count data and phylogenetic info|
| Covariates     | Input      |  .csv | One csv file that contains the values of covariates|
| Phenotype | Input     |    .csv | One csv file that contains the values of phenotypes |
| Output | Output     |    .csv | Multiple csv files that contains variance components estimation, negative log-likelihood or AIC/BIC for each tuning parameter.

# Kernel Distance Matrices files

UniFrac is a distance matrix used for comparing biological communities. More information about the UniFrac distance is [here](https://en.wikipedia.org/wiki/UniFrac). UniFrac distance can be calculated using Julia package [_PhylogeneticDistance.jl_](https://github.com/JingZhai63/PhylogeneticDistance.jl). Microbiome count file and phylogenetic tree file are needed. The distance matrix need be transformed to positive-definite kernel matrix and be scaled to have unit Frobenius norm.

* Kernel matrices files should have same order with phenotype file and covariate file
* Do not include column names and row names in kernel matrices files

# Covariates file

Covariates file is a .csv file that contains the values of covariates. In covariates file, each line represents one measurement for one subject. The intercept should NOT be included. A typical covariates file look like

If a specific covariate value is missing, please impute by mean.  If no covariates file is provided, the covariates matrix **X** will be automatically set to a _n_-by-1 matrix with all elements equal to 1, where n is the number of individuals.

```csv
id	    time	X1	    X2
id_001	t0	  1.857     1.492
id_001	t1	  0.747     2.414
id_001	t2	 -0.652     0.887
id_002	t0	 -0.993     0.476
id_002	t1	  0.737    -0.041
id_002	t2	  0.309     0.230
id_003	t0	  0.205    -0.223
id_003	t1	 -1.705     0.631
id_003	t2	  0.307     0.337
```

# Phenotype file

Phenotype file is a txt file that contains the values of phenotypes. In phenotype file, each line represents one measurement at one time point. One subject may have several repeated measurements. The format of phenotype file is the same as covariate file. The fields in phenotype file are

* Subject ID
* Measurement Time
* Measurement ID (optional)
* Phenotypes

```csv
id	    time	 outcome1	outcome2	outcome3	outcome4   outcome5
id_001	t0	   -1.114  	-1.598    	-2.825    4.140	   3.023
id_001	t1	    1.138   	2.872	     1.240    1.767	   3.016
id_001	t2	   -0.081  	 0.548	    -1.447    0.094	  -0.807
id_002	t0	    3.987      -2.001    	-0.998   -0.689      -0.790
id_002	t1	    1.617   	1.480	    -1.159   -3.790       0.026
id_002	t2	    2.964   	3.026	    -0.437    1.777	  -0.446
id_003	t0	    1.087      -2.223    	-1.900   -3.228       0.075
id_003	t1	    2.791      -0.375    	 0.170    2.168	  -1.286
id_003	t2	    1.708   	1.255	    -2.569    1.651	   1.769

```

# Output file

By default, output have two files: one includes the variance components estimation and one contains negative log-likelihood under each tuning parameter. In estimation output file, each line represents for one variance component and each column represents for one tuning parameter. In negative log-likelihood file, each line represents for one tuning parameter.

If users indicate the criterion (i.e., AIC/BIC), the **VCselection** will output another two files, one contains the AIC/BIC for all tuning parameter and the other one contains the variance components estimation with lowest AIC/BIC value. The file name includes the optimal tuning parameter selected by AIC/BIC.


text:
# gitops-istio

This guide walks you through setting up Istio on a Kubernetes cluster and
automating canary deployments with GitOps pipelines.

![Progressive Delivery GitOps Pipeline](https://raw.githubusercontent.com/weaveworks/flagger/master/docs/diagrams/flagger-gitops-istio.png)

Components:

* **Istio** service mesh
    * manages the traffic flows between microservices, enforcing access policies and aggregating telemetry data
* **Prometheus** monitoring system
    * time series database that collects and stores the service mesh metrics
* **Flux** GitOps operator
    * syncs YAMLs and Helm charts between git and clusters
    * scans container registries and deploys new images
* **Helm Operator** CRD controller
    * automates Helm chart releases
* **Flagger** progressive delivery operator
    * automates the promotion of canary deployments using Istio routing for traffic shifting and Prometheus metrics for canary analysis

### Prerequisites

You'll need a Kubernetes cluster **v1.11** or newer with `LoadBalancer` support,
`MutatingAdmissionWebhook` and `ValidatingAdmissionWebhook` admission controllers enabled.
For testing purposes you can use Minikube with two CPUs and 4GB of memory.

Install Flux CLI, Helm and Tiller :

```bash
brew install fluxctl kubernetes-helm

kubectl -n kube-system create sa tiller

kubectl create clusterrolebinding tiller-cluster-rule \
--clusterrole=cluster-admin \
--serviceaccount=kube-system:tiller

helm init --service-account tiller --wait
```

Fork this repository and clone it :

```bash
git clone https://github.com/<YOUR-USERNAME>/gitops-istio
cd gitops-istio
```

### Cluster bootstrap

Install Weave Flux and its Helm Operator by specifying your fork URL:

```bash
./scripts/flux-init.sh git@github.com:<YOUR-USERNAME>/gitops-istio
```

At startup, Flux generates a SSH key and logs the public key. The above command will print the public key.

In order to sync your cluster state with git you need to copy the public key and create a deploy key with write
access on your GitHub repository. On GitHub go to _Settings > Deploy keys_ click on _Add deploy key_,
check _Allow write access_, paste the Flux public key and click _Add key_.

When Flux has write access to your repository it will do the following:

* creates the `istio-system` and `prod` namespaces
* creates the Istio CRDs
* installs Istio Helm Release
* installs Flagger Helm Release
* installs Flagger's Grafana Helm Release
* creates the load tester deployment
* creates the frontend deployment and canary
* creates the backend deployment and canary
* creates the Istio public gateway

![Helm Operator](https://raw.githubusercontent.com/stefanprodan/openfaas-flux/master/docs/screens/flux-helm.png)

The Flux Helm operator provides an extension to Weave Flux that automates Helm Chart releases for it.
A Chart release is described through a Kubernetes custom resource named HelmRelease.
The Flux daemon synchronizes these resources from git to the cluster, and the Flux Helm operator makes sure
Helm charts are released as specified in the resources.

Istio Helm Release example:

```yaml
apiVersion: flux.weave.works/v1beta1
kind: HelmRelease
metadata:
  name: istio
  namespace: istio-system
spec:
  releaseName: istio
  chart:
    repository: https://storage.googleapis.com/istio-release/releases/1.1.4/charts
    name: istio
    version: 1.1.4
  values:
    pilot:
      enabled: true
    gateways:
      enabled: true
      istio-ingressgateway:
        type: LoadBalancer
    sidecarInjectorWebhook:
      enabled: true
    mixer:
      policy:
        enabled: false
      telemetry:
        enabled: true
    prometheus:
      enabled: true
      scrapeInterval: 5s
```

Note that the Istio CRDs have been extracted from the istio-init chart and placed inside the istio-system dir.
You can update the CRDs by running the `./scripts/istio-init.sh` script.

If you make changes to the Istio configuration and push those to git, Flux will upgrade the Helm release.
It can take up to 3 minutes for Flux to sync and apply the changes or you can use `fluxctl sync` to trigger a git sync.

### Workloads bootstrap

When Flux syncs the Git repository with your cluster, it creates the frontend/backend deployment, HPA and a canary object.
Flagger uses the canary definition to create a series of objects: Kubernetes deployments,
ClusterIP services and Istio virtual services. These objects expose the application on the mesh and drive
the canary analysis and promotion.

```bash
# applied by Flux
deployment.apps/frontend
horizontalpodautoscaler.autoscaling/frontend
canary.flagger.app/frontend

# generated by Flagger
deployment.apps/frontend-primary
horizontalpodautoscaler.autoscaling/frontend-primary
service/frontend
service/frontend-canary
service/frontend-primary
virtualservice.networking.istio.io/frontend
```

Check if Flagger has successfully initialized the canaries:

```
kubectl -n prod get canaries

NAME       STATUS        WEIGHT   LASTTRANSITIONTIME
backend    Initialized   0        2019-04-30T18:53:18Z
frontend   Initialized   0        2019-04-30T17:50:50Z
```

When the `frontend-primary` deployment comes online,
Flagger will route all traffic to the primary pods and scale to zero the `frontend` deployment.

### Automated canary promotion

Flagger implements a control loop that gradually shifts traffic to the canary while measuring key performance indicators
like HTTP requests success rate, requests average duration and pod health.
Based on analysis of the KPIs a canary is promoted or aborted, and the analysis result is published to Slack.

A canary deployment is triggered by changes in any of the following objects:
* Deployment PodSpec (container image, command, ports, env, etc)
* ConfigMaps mounted as volumes or mapped to environment variables
* Secrets mounted as volumes or mapped to environment variables

For workloads that are not receiving constant traffic Flagger can be configured with a webhook,
that when called, will start a load test for the target workload. The backend load test webhook configuration can be found
at `prod/backend/canary.yaml`.

![Flagger Load Testing Webhook](https://raw.githubusercontent.com/weaveworks/flagger/master/docs/diagrams/flagger-load-testing.png)

Trigger a canary deployment for the backend app by updating the container image:

```bash
$ export FLUX_FORWARD_NAMESPACE=flux

$ fluxctl release --workload=prod:deployment/backend \
--update-image=quay.io/stefanprodan/podinfo:1.4.1

Submitting release ...
WORKLOAD                 STATUS   UPDATES
prod:deployment/backend  success  backend: quay.io/stefanprodan/podinfo:1.4.0 -> 1.4.1
Commit pushed:	ccb4ae7
Commit applied:	ccb4ae7
```

Flagger detects that the deployment revision changed and starts a new rollout:

```bash
$ kubectl -n prod describe canary backend

Events:

New revision detected! Scaling up backend.prod
Starting canary analysis for backend.prod
Advance backend.prod canary weight 5
Advance backend.prod canary weight 10
Advance backend.prod canary weight 15
Advance backend.prod canary weight 20
Advance backend.prod canary weight 25
Advance backend.prod canary weight 30
Advance backend.prod canary weight 35
Advance backend.prod canary weight 40
Advance backend.prod canary weight 45
Advance backend.prod canary weight 50
Copying backend.prod template spec to backend-primary.prod
Promotion completed! Scaling down backend.prod
```

During the analysis the canary’s progress can be monitored with Grafana. You can access Grafana using port forwarding:

```bash
kubectl -n istio-system port-forward svc/flagger-grafana 3000:80
```

The Istio dashboard URL is
http://localhost:3000/d/flagger-istio/istio-canary?refresh=10s&orgId=1&var-namespace=prod&var-primary=backend-primary&var-canary=backend

![Canary Deployment](https://raw.githubusercontent.com/weaveworks/flagger/master/docs/screens/demo-backend-dashboard.png)

Note that if new changes are applied to the deployment during the canary analysis, Flagger will restart the analysis phase.

### Automated A/B testing

Besides weighted routing, Flagger can be configured to route traffic to the canary based on HTTP match conditions.
In an A/B testing scenario, you'll be using HTTP headers or cookies to target a certain segment of your users.
This is particularly useful for frontend applications that require session affinity.

You can enable A/B testing by specifying the HTTP match conditions and the number of iterations:

```yaml
  canaryAnalysis:
    # schedule interval (default 60s)
    interval: 10s
    # max number of failed metric checks before rollback
    threshold: 10
    # total number of iterations
    iterations: 12
    # canary match condition
    match:
      - headers:
          user-agent:
            regex: "^(?!.*Chrome)(?=.*\bSafari\b).*$"
      - headers:
          cookie:
            regex: "^(.*?;)?(type=insider)(;.*)?$"
```

The above configuration will run an analysis for two minutes targeting Safari users and those that
have an insider cookie. The frontend configuration can be found at `prod/frontend/canary.yaml`.

Trigger a deployment by updating the frontend container image:

```bash
$ fluxctl release --workload=prod:deployment/frontend \
--update-image=quay.io/stefanprodan/podinfo:1.4.1
```

Flagger detects that the deployment revision changed and starts the A/B testing:

```bash
$ kubectl -n istio-system logs deploy/flagger -f | jq .msg

New revision detected! Scaling up frontend.prod
Waiting for frontend.prod rollout to finish: 0 of 1 updated replicas are available
Advance frontend.prod canary iteration 1/10
Advance frontend.prod canary iteration 2/10
Advance frontend.prod canary iteration 3/10
Advance frontend.prod canary iteration 4/10
Advance frontend.prod canary iteration 5/10
Advance frontend.prod canary iteration 6/10
Advance frontend.prod canary iteration 7/10
Advance frontend.prod canary iteration 8/10
Advance frontend.prod canary iteration 9/10
Advance frontend.prod canary iteration 10/10
Copying frontend.prod template spec to frontend-primary.prod
Waiting for frontend-primary.prod rollout to finish: 1 of 2 updated replicas are available
Promotion completed! Scaling down frontend.prod
```

You can monitor all canaries with:

```bash
$ watch kubectl get canaries --all-namespaces

NAMESPACE   NAME      STATUS        WEIGHT   LASTTRANSITIONTIME
prod        frontend  Progressing   100      2019-04-30T18:15:07Z
prod        backend   Succeeded     0        2019-04-30T17:05:07Z
```

### Automated rollback

During the canary analysis you can generate HTTP 500 errors and high latency to test Flagger's rollback.

Generate HTTP 500 errors:

```bash
watch curl -b 'type=insider' http://<INGRESS-IP>/status/500
```

Generate latency:

```bash
watch curl -b 'type=insider' http://<INGRESS-IP>/delay/1
```

When the number of failed checks reaches the canary analysis threshold, the traffic is routed back to the primary,
the canary is scaled to zero and the rollout is marked as failed.

```text
kubectl -n prod describe canary/frontend

Status:
  Failed Checks:         2
  Phase:                 Failed
Events:
  Type     Reason  Age   From     Message
  ----     ------  ----  ----     -------
  Normal   Synced  3m    flagger  Starting canary deployment for frontend.prod
  Normal   Synced  3m    flagger  Advance frontend.prod canary iteration 1/10
  Normal   Synced  3m    flagger  Advance frontend.prod canary iteration 2/10
  Normal   Synced  3m    flagger  Advance frontend.prod canary iteration 3/10
  Normal   Synced  3m    flagger  Halt frontend.prod advancement success rate 69.17% < 99%
  Normal   Synced  2m    flagger  Halt frontend.prod advancement success rate 61.39% < 99%
  Warning  Synced  2m    flagger  Rolling back frontend.prod failed checks threshold reached 2
  Warning  Synced  1m    flagger  Canary failed! Scaling down frontend.prod
```

### Alerting

Flagger can be configured to send Slack notifications.
You can enable alerting by adding the Slack settings to Flagger's Helm Release:

```yaml
apiVersion: flux.weave.works/v1beta1
kind: HelmRelease
metadata:
  name: flagger
  namespace: istio-system
  annotations:
    flux.weave.works/automated: "false"
    flux.weave.works/tag.chart-image: semver:~0
spec:
  releaseName: flagger
  chart:
    repository: https://flagger.app
    name: flagger
    version: 0.12.0
  values:
    slack:
      user: flagger
      channel: general
      url: https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK
```

Once configured with a Slack incoming **webhook**, Flagger will post messages when a canary deployment
has been initialised, when a new revision has been detected and if the canary analysis failed or succeeded.

![Slack Notifications](https://raw.githubusercontent.com/weaveworks/flagger/master/docs/screens/slack-canary-notifications.png)

A canary deployment will be rolled back if the progress deadline exceeded or if the analysis reached the
maximum number of failed checks:

![Slack Notifications](https://raw.githubusercontent.com/weaveworks/flagger/master/docs/screens/slack-canary-failed.png)

Besides Slack, you can use Alertmanager to trigger alerts when a canary deployment failed:

```yaml
  - alert: canary_rollback
    expr: flagger_canary_status > 1
    for: 1m
    labels:
      severity: warning
    annotations:
      summary: "Canary failed"
      description: "Workload {{ $labels.name }} namespace {{ $labels.namespace }}"
```


text:
---
title: Rebuilding statistics from previous months on Plesk 8.3
author: Major Hayden
type: post
date: 2008-06-20T17:00:06+00:00
url: /2008/06/20/rebuilding-statistics-from-previous-months-on-plesk-83/
dsq_thread_id:
  -<PHONE_NUMBER>
categories:
  - Blog Posts
tags:
  - awstats
  - plesk

---
There was a bug in versions of Plesk prior to 8.3 where the AWStats statistics for the previous months were unavailable. It was a bug within Plesk's AWStat's implementation, and it was fixed in Plesk 8.3.

However, the fix only corrected the issue moving forward after the upgrade. There was no automated way to rebuild the previous months' statistics, _even though the AWStats data was right there on the disk_!

I saw this blog post about the issue, and the fix is quite elegant:

[Plesk 8.3 AWStats on Linux - Rebuilding Previous Month Statistics][1]

 [1]: http://www.europheus.com/?p=67


text:
# FAQ {docsify-ignore-all}
---
### Does Homebrew have any risks?

Currently homebrewing the Wii U does not expose you to a risk of being banned by Nintendo unless you cheat in online games. You should, however, always be careful with launching downloaded homebrew, especially if you don't trust the source, as Homebrew can potentially damage your system!

### What is Haxchi, and do I need it?

Haxchi is a secondary entry point which uses certain DS Virtual Console titles to allow for access to homebrew while being completely offline (still works with online but no connection required to launch CFW)

Haxchi is not required, however, if you want to use homebrew on your Wii U while offline you will need it. It’s highly recommended as it’s more stable than the browser entry point, especially on the newest firmware.

The cheapest DS VC games usable for this exploit:
 - Dr. Kawashima's Brain Training [PAL]
 - Brain Age: Train Your Brain in Minutes a Day! [USA]
 - Kawashima: Motto Nou wo Kitaeru Otona no DS Training [JPN]

### Can I install games from my USB instead of SD?

Yes. It is, however, a bit more complicated than installing from SD Card. Detailed instructions are in the `Install from USB` tab in the [Dumping guide](dump-games).

### How to Delete Update Folder to Block Updates on Wii U

If you want to delete the update folder to block updates, see its tab in the [Blocking Updates guide](block-updates).

### What SD Card size is recommended?

 - **Installing game backups:** 32 GB  (Smaller size may be used, but certain titles are 20 GB in size)
 - **Running game mods:** 8 GB  (FAT32 USB drive may be used as well for mods)
 - **Only running homebrew apps:** Any size

**Recommended brands:** SanDisk, Samsung or PNY

?> Note: Avoid class 4 SD Cards, and avoid eBay!

### Can I install homebrew on Wii U with a USB instead of SD Card?

No, you must have an SD Card for a first time setup, a USB can then be used to install game backups, VC injects, etc, but not to store Homebrew Apps which are required to set everything up.

### When extracting some of the files there are duplicates of certain ones called "info.json" & "manifest.install", what do I do with those?

Nothing special, you can leave them there, delete them or replace them with new ones. Those files are not used in the process, therefore, won't have any impact by being or not being there.

It's a USB drive that has been formatted by a Wii U console to its proprietary format.
A Wii U formatted USB drive ***cannot be read by any other devices than the Wii U that originally formatted it.***
If you ever want to use it with another Wii U console or any other devices, you will have to reformat it.

license: ISC


text:
# RVCodeGen

## Description

TODO add description

## Installation

### 1. Setting up LLVM

Start in your project root folder. Clone the [LLVM sources](https://github.com/llvm-mirror/llvm) as `llvm`. Next, clone the [Clang sources](https://github.com/llvm-mirror/clang) into `llvm/tools`. Make sure to checkout the same version branch in both of these repositories.

### 2. Setting up RVCodeGen

Clone this repository into `llvm/projects`.

### 3. Building LLVM+Clang+RVCodeGen

Create a new folder `build` in your project root folder and `cd` into it. Create build files via `cmake` with the following command:

```
cmake -G <build tool> <additional flags> ../llvm/
```

where `<build tool>` is your preferred build tool (e.g. `"Unix Makefile"` or `Ninja`).
Interesting additional flags for development are:

  * `-DLLVM_ENABLE_ASSERTIONS=1` to enforce assertions in the code
  * `-DCMAKE_BUILD_TYPE=Debug` to enable a debug build for better error messages and debugging capabilities
  * `-DLLVM_PARALLEL_LINK_JOBS=<n>` to limit the number of concurrent link jobs to `<n>`. This should be rather low for systems with less than 8GB of RAM as linking `clang` can require considerable amounts of memory (especially when building a debug build)
  * `-DLLVM_TARGETS_TO_BUILD=X86` to reduce build time by building only the X86 backend

When the build files are generated, use your build system to build the project (e.g. by typing `make` or `ninja`). This might take a while.

### 4. Build Targets

This project defines additional build targets to use with the build system:

  * `check-RVCodeGen` to run the test suite
  * `RVCodeGen-update-format` to run `clangformat` on all `RVCodeGen` source files

license: NCSA

repository: sierra-lang/libsierra

repo_name: sierra-lang/libsierra


text:
# Harrastuspassi iOS

> Harrastuspassi project consists of Android and iOS mobile applications, a web based admin user interface and a backend system. This is the repository for the iOS application.

[![Swift Version][swift-image]][swift-url]

## Requirements

- MacOS 10.14.4+
- iOS 11.0+
- Xcode 10.2+

## Setting up development environment

Clone this project to your local machine using `git clone`.

To get the project up and running you'll need to create:

`/Harrastupassi/Config.swift`

and add the following contents with an API URL and a valid Google Maps SDK API-key:

```
//  Config.swift
//  Harrastuspassi

import Foundation

class Config {
    static let API_URL: String = "<YOUR_API_URL>"
    static let GM_API_KEY = "<YOUR_GOOGLE_MAPS_API_KEY>"
}
```

After this you'll be able to use `Harrastuspassi.xcworkspace` to start developing in XCode. :sunglasses:

## Related projects

You can view the Harrastuspassi project's main repository, with links to other related projects [here.](https://github.com/City-of-Helsinki/harrastuspassi)

[swift-image]: https://img.shields.io/badge/swift-5.1-orange.svg
[swift-url]: https://swift.org/

repository: City-of-Helsinki/harrastuspassi-ui-ios

gha_language: Swift

repo_name: City-of-Helsinki/harrastuspassi-ui-ios


text:
# Dracula for [Couscous](http://couscous.io/).

> A dark theme for [Couscous](http://couscous.io/).

![Screenshot](screenshot.png)

## Install

All instructions can be found at [Couscous](http://couscous.io/docs/getting-started.html).

To use the template, set it up in your couscous.yml configuration file:
```
template:
    url: https://github.com/BilelJegham/DraculaThemeCousous.git
```

## Team

This theme is maintained by the following person and a bunch of [awesome contributors](https://github.com/dracula/template/graphs/contributors).

|[![Bilel Jegham](https://avatars0.githubusercontent.com/u/20130405?v=3&s=70)](https://github.com/BilelJegham) |
|---|
|[Bilel Jegham](https://github.com/BilelJegham) |

## License

[MIT License](./LICENSE)

repository: BilelJegham/DraculaThemeCousous

repo_name: BilelJegham/DraculaThemeCousous


text:
# YouTube CL AIO MP4 APIS
Download Mixed Data From YouTube

# Hosted MP4 API
    https://paidcodes.albdroid.al/Youtube_APIS/MP4

# Get Types

    download    = Direct Downloader [bool -> ?url=URL or ID&type=download]
    mp4         = Smart TV BOX Player [bool -> ?url=URL or ID&type=mp4]
    play        = Direct Player [bool -> ?url=URL or IDL&type=play]
    m3u         = Create M3U Structure [bool -> ?url=URL or ID&type=m3u]
    raw         = Print String Only [bool -> ?url=URL or ID&type=raw]
    xtream      = Xtream Codes [bool -> ?url=URL or ID&type=xtream]
    vlc         = Create VLC Structure [bool -> ?url=URL or ID&type=vlc]
    smart       = Smart TV Structure [bool -> ?url=URL or ID&type=smart]
    kodi Direct = LSP Kodi Structure [bool -> ?url=URL or IDL&type=kodi]
    kodi Regex  = LSP Kodi Structure [bool -> ?url=URL or IDL&type=kodi_regex]
    json        = JSON With Entry Attribute [bool -> ?url=URL or ID&type=json]
    simple_json = JSON Without Entry Attribute [bool -> ?url=URL or ID&type=simple_json]
    json_down   = DOWNLOAD JSON DATA [bool -> ?url=URL or ID&type=json_down]
    clp         = Clappr Player [bool -> ?url=URL or IDL&type=clp]
    jwp         = JW Player [bool -> ?url=URL or ID no needed &type IS Default Player, if u see kodi video => no stream source]

# Errors

    At the moment api has problem only with some Official Artist Channel Profiles [VEVO] ex: => F80QIeequEI
    in some profiles it works and in some it does not.
https://github.com/SxtBox/YouTube_CL_AIO_APIS/tree/main/MP4_AIO_Player/Screenshots/Error_Detect

# Smart TV Playlist Test

https://siptv.eu/mylist

Go to URL: TAB

Paste this url https://paidcodes.albdroid.al/Youtube_APIS/MP4/smart

Check Save online [box] And press SEND

# PHP INFO
    AL: Të Gjitha Këto PHP Punojnë në Çdo Server me curl extensions Të Aktivizuar
    EN: All These PHP Works on Any Server With curl extensions Activated

# RULES
    AL: KETA API JANE VETEM PER DEMOSTRIM, NESE JU E KEQPERDORNI DO TE HUMBISNI KOMUNIKIMIN ME SERVERAT TANE
    EN: THESE APIS ARE FOR DEMONSTRATION ONLY, IF YOU MISUSE IT YOU WILL LOSE COMMUNICATION WITH OUR SERVERS

# BIG THANKS TO

Clappr Player https://github.com/clappr

JW Player https://github.com/jwplayer


text:
---
layout: default
---

# 1997-03-11 - Failed mail

## Header Data

From: NTMail<EMAIL_ADDRESS>To: _N/A_

Message Hash: c104ad0ffa5acaf009eb60c844ff9a6f8e1db3e5db443bc71793ecf02c3ef8b6

Message ID: \<ya227160.mbx\>

Reply To: _N/A_

UTC Datetime: 1997-03-11 14:57:48 UTC

Raw Date: Tue, 11 Mar 1997 06:57:48 -0800 (PST)

## Raw message

```
{% raw  %}From: NTMail<EMAIL_ADDRESS>Date: Tue, 11 Mar 1997 06:57:48 -0800 (PST)
Subject: Failed mail
Message-ID: <ya227160.mbx>
MIME-Version: 1.0
Content-Type: text/plain

---------------------------------------------------------------------
Your message to mail.astrobiz.com was rejected.
I said:
    RCPT<EMAIL_ADDRESS>And mail.astrobiz.com responded with
    553<EMAIL_ADDRESS>Unbalanced '<'
---------------------------------------------------------------------
Your message follows:

>Received: from [<IP_ADDRESS>] by smtp1.abraxis.com (NTMail 3.01.03) id ya227160; Tue, 11 Mar 1997 10:02:40 -0500
>Subject: transmits Section of Vice of is right
>Date: Tue, 11 Mar 1997 10:02:40 -0500
>Message-Id<EMAIL_ADDRESS>>
>compensation the Job the in House corrections.  HR the Act Introduced property date and
>HR Act the HR Frivolous Introduced To.  lobbyist HR of of in House Squad
>To THE free be not except nor.  which in inflicted of Powers most apportioned
>be be Writs one third XVII but.  they of
>.

{% endraw %}
```

## Thread

+ Return to [March 1997](/archive/1997/03)

+ Return to "[NTMail <postmaster@abraxis.com>](/authors/ntmail_postmaster_at_abraxis_com_)"

+ 1997-03-11 (Tue, 11 Mar 1997 06:57:48 -0800 (PST)) - Failed mail - _NTMail<EMAIL_ADDRESS>


text:
# Installing NodeBB on Windows

17-313 will only be supporting development using Windows Subsystem Linux 2 (WSL2) on Windows (Ubuntu variant). To support the use of WSL2, it is **highly recommended** that you develop using [VSCode](https://code.visualstudio.com/download).

To learn more, refer to Microsoft's official [WSL Documentation](https://learn.microsoft.com/en-us/windows/wsl/about).

## Installing WSL2 on Windows

Follow the instructions on the official Microsoft [Getting Started Guide](https://learn.microsoft.com/en-us/windows/wsl/setup/environment#get-started) and complete all the steps up to (and including) the [**Use Visual Studio Code**](https://learn.microsoft.com/en-us/windows/wsl/setup/environment#use-visual-studio-code) section.

By the end of these instructions, you should:

- [ ] Have Ubuntu WSL2 installed
- [ ] Have a root Linux username and password set up
- [ ] Have updated and upgraded your packages
- [ ] Be able to open Ubuntu WSL2 in Windows Terminal
- [ ] Understand that you should [**store your project files on the same operating system as the tools you plan to use**](https://learn.microsoft.com/en-us/windows/wsl/filesystems#file-storage-and-performance-across-file-systems). For example, in order to successfully run NodeBB in Ubuntu, you should run `git clone` in your Ubuntu file system, open the cloned directory in Ubuntu, and edit the code files in Ubuntu
- [ ] Be able to open a directory in Ubuntu in VSCode

!!! note
    In all future projects of this course, we will expect you to develop using WSL2. Thus, it is **very important** that you set up WSL2 correctly. Please come to office hours or ask on Slack if you need any assistance with the installation.

## Installing NodeBB
If you do not already have Git installed, follow the [**Git Installation on Linux**](https://github.com/git-guides/install-git#install-git-on-linux) for Ubuntu.

Then, follow the [Ubuntu](/projects/P1/installation/ubuntu) instructions to install required tools and NodeBB itself on WSL2.

gha_language: HTML


text:
#### Keep object key with escape sequence as it is ([#8160](https://github.com/prettier/prettier/pull/8160) by [@fisker](https://github.com/fisker))

<!-- prettier-ignore -->
```js
// Input
const a = {
  "\u2139": 'why "\\u2139" converted to "i"?',
};

// Prettier stable
const a = {
  ℹ: 'why "\\u2139" converted to "i"?',
};

// Prettier master
const a = {
  "\u2139": 'why "\\u2139" is converted to "i"?',
};
```


text:
# Amarenographium metableticum (Trail) O.E. Erikss., 1982 SPECIES

#### Status
SYNONYM

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

#### Published in
Mycotaxon 15: 199 (1982)

#### Original name
Camarosporium metableticum Trail, 1886

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Ascomycota/Dothideomycetes/Pleosporales/Amarenomyces/Amarenomyces ammophilae/ Syn. Amarenographium metableticum/README.md

repo_name: mdoering/backbone


text:
Task description

You are given integers K, M and a non-empty zero-indexed array A consisting of N integers. Every element of the array is not greater than M.

You should divide this array into K blocks of consecutive elements. The size of the block is any integer between 0 and N. Every element of the array should belong to some block.

The sum of the block from X to Y equals A[X] + A[X + 1] + ... + A[Y]. The sum of empty block equals 0.

The large sum is the maximal sum of any block.

For example, you are given integers K = 3, M = 5 and array A such that:

```
  A[0] = 2
  A[1] = 1
  A[2] = 5
  A[3] = 1
  A[4] = 2
  A[5] = 2
  A[6] = 2
```
The array can be divided, for example, into the following blocks:

```
[2, 1, 5, 1, 2, 2, 2], [], [] with a large sum of 15;
[2], [1, 5, 1, 2], [2, 2] with a large sum of 9;
[2, 1, 5], [], [1, 2, 2, 2] with a large sum of 8;
[2, 1], [5, 1], [2, 2, 2] with a large sum of 6.
```
The goal is to minimize the large sum. In the above example, 6 is the minimal large sum.

Write a function:

```
function solution(K, M, A);
```

that, given integers K, M and a non-empty zero-indexed array A consisting of N integers, returns the minimal large sum.

For example, given K = 3, M = 5 and array A such that:

```
  A[0] = 2
  A[1] = 1
  A[2] = 5
  A[3] = 1
  A[4] = 2
  A[5] = 2
  A[6] = 2
```
the function should return 6, as explained above.

Assume that:

* N and K are integers within the range [1..100,000];
* M is an integer within the range [0..10,000];
* each element of array A is an integer within the range [0..M].

Complexity:

* expected worst-case time complexity is O(N*log(N+M));
* expected worst-case space complexity is O(1), beyond input storage (not counting the storage required for input arguments).

Elements of input arrays can be modified.

```javascript
function solution(K, M, A) {
    var begin = A.reduce((a, v) => (a + v), 0)
    begin = parseInt((begin+K-1)/K, 10);
    var maxA = Math.max(A);
    if (maxA > begin) begin = maxA;

    var end = begin + M + 1;
    var res = 0;

    while(begin <= end) {
        var mid = (begin + end) / 2;
        var sum = 0;
        var block = 1;
        for (var ind in A) {
            var a = A[ind];
            sum += a;
            if (sum > mid) {
                ++block;
                if (block > K) break;
                sum = a;
            }
        }
        if (block > K) {
            begin = mid + 1;
        } else {
            res = mid;
            end = mid - 1;
        }
    }
    return res;
}
```


text:
---
layout: page
title: Word Studies
displayIndex: false
---
<br />

 **parochial** [puh-roh-kee-uh l]

- adjective
- of, relating to, or financially supported by one or more church parishes: parochial churches in Great Britain.
- of or relating to parochial schools or the education they provide.
- very limited or narrow in scope or outlook; provincial: parochial views; a parochial mentality.

The fundamentalist had a parochial view of religon.

---

**anodyne** [an-uh-dahyn]

- noun
- a medicine that relieves or allays pain.
- anything that relieves distress or pain: The music was an anodyne to his grief.
- adjective
- relieving pain.
- soothing to the mind or feelings.

The pastor spoke smooth, anodyne words to them.

---

**fail-safe** [feyl-seyf]

- adjective
- equipped with a secondary system that insures continued operation even if the primary system fails.
- guaranteed to work; totally reliable: a fail-safe recipe for a cheese soufflé.
- noun
- something designed to work or function automatically to prevent breakdown of a mechanism, system, or the like.
- verb (used with object), fail-safed, fail-safing.
- to make fail-safe.


text:
# Snakemake workflow: {{cookiecutter.project_name}}

[![Snakemake](https://img.shields.io/badge/snakemake-≥{{cookiecutter.min_snakemake_version}}-brightgreen.svg)](https://snakemake.bitbucket.io)
[![Build Status](https://travis-ci.org/snakemake-workflows/{{cookiecutter.repo_name}}.svg?branch=master)](https://travis-ci.org/snakemake-workflows/{{cookiecutter.repo_name}})

## Authors

* {{cookiecutter.full_name}} (@{{cookiecutter.username}})

## Usage

### Step 1: Install workflow and dependencies

If you simply want to use this workflow, clone the [latest release](https://github.com/bfairkun/{{cookiecutter.repo_name}}).

    git clone git@github.com:{{cookiecutter.username}}/{{cookiecutter.repo_name}}.git

If you intend to modify and further develop this workflow, fork this repository. Please consider providing any generally applicable modifications via a pull request.

Install snakemake and the workflow's other dependencies via conda/mamba. If conda/mamba isn't already installed, I recommend [installing miniconda](https://docs.conda.io/en/latest/miniconda.html) and then [install mamba](https://github.com/mamba-org/mamba) in your base environment. Then...

    # move to the snakemake's working directory
    cd {{cookiecutter.repo_name}}/code
    # Create environment for the snakemake
    mamba env create -f envs/{{ cookiecutter.repo_name }}.yaml
    # And activate the enviroment
    conda activate {{ cookiecutter.repo_name }}

### Step 2: Configure workflow

Configure the workflow according to your needs via editing the file `config.yaml`. Use/modify the config yaml files in the `snakemake_profiles/slurm/` profile to run on UChicago RCC Midway with slurm scheduler.

### Step 3: Execute workflow

Test your configuration by performing a dry-run via

    snakemake -n

Execute the workflow locally via

    snakemake --cores $N

using `$N` cores or run it in a cluster environment via the included slurm snakemake profile.

    snakemake --profile snakemake_profiles/slurm

See the [Snakemake documentation](https://snakemake.readthedocs.io) for further details.

repository: bfairkun/cookiecutter-wflowR-smk

repo_name: bfairkun/cookiecutter-wflowR-smk


text:
# GDPR and Zwift's Developer API
In July '08, this library was converted to use Zwift's new Developer API, in accordance with Zwift's policies.

The Developer API requires a special developer account, and won't work with regular rider accounts like before.
Currently, Zwift is not able to offer developer accounts to hobby developers, but I'm hoping they'll be able to at some point.
You can contact Zwift at [developers<EMAIL_ADDRESS>to register interest and ask for further information.

# zwift-mobile-api
A simple javascript library to make it a bit easier to call some of the Zwift API endpoints

* Automatically handle creating and renewing of a valid token (requires username and password to login with a valid Zwift account)
* Decode protobuf data to get live current speed/power/time data for currently riding players
* List and download previous activities, decoded from FIT files

# Usage

```
$> npm install --save zwift-mobile-api
```

## Login

```javascript
var ZwiftAccount = require("zwift-mobile-api");
var account = new ZwiftAccount(username, password);
```

## Rider Profiles

```javascript
// Get profile for "me"
account.getProfile().profile().then(p => {
    console.log(p);  // JSON of rider profile (includes id property you can use below)
});

// Get profile data for a particular rider (requires Zwift player id)
var profile = account.getProfile(playerId);

profile.followers().then(followers => {
    console.log(followers); // JSON array of rider's followers
});

profile.followees().then(followees => {
    console.log(followees); // JSON array of rider's followees
});

// Give a RideOn (from 'playerId' to 'otherRiderId')
// Can lookup 'activityId' from 'currentActivityId' of profile() response
profile.giveRideOn(otherRiderId, activityId);

// Retrieve the goals you have
profile.goals().then(goal=> {
    console.log(goal); //JSON array of goals
})

// Delete a goal; goalID is printed from getGoals()
goalID = 200147
prof.deleteGoal(goalID)
```

## List Riders

```javascript
// (note: currently all riders are listed in world '1',
// so worlds 2 and 3 are empty no matter the schedule)

var world = account.getWorld(1);

world.riders().then(riders => {
    console.log(riders); // JSON array of all riders currently riding
});
```

## Rider Status

```javascript
// (note: currently all riders are listed in world '1',
// so worlds 2 and 3 are empty no matter the schedule)

var world = account.getWorld(1);

// Get the status of the specified rider
// (includes x,y position, speed, power, etc)
world.riderStatus(playerId).then(status => {
    console.log(status); // JSON of rider status
});

```

## Events

```javascript
var event = account.getEvent();

// Search for events
// options:
//   eventStartsAfter = earliest start time (milliseconds since 1970)
//   eventStartsBefore = latest start time (milliseconds since 1970)
const options = {
    eventStartsAfter: Date.now() - 3600000,
    eventStartsBefore: Date.now() + 600000
};
event.search(options).then(results => {
    results.forEach(event => console.log(
        `${event.id}: ${event.name} - sub groups `
        + event.eventSubgroups.map(g => `${g.label}:${g.id}`)
    ))
});

// Get riders who signed up to an event sub group
// (get subGroupId from search() results)
event.riders(subGroupId).then(riders =>
    riders.forEach(r => console.log(
        `${r.id} - ${r.firstName} ${r.lastName}`
    ))
);

// Get the results for an event subgroup.
// Note that results returned by Zwift are not sorted, even though they
// often come through as slowest first.
event.segmentResults(eventSubgroupId).then(results => {
    results.sort((a,b) => {
        if (a.elapsedMs > b.elapsedMs) {
            return 1;
        } else if (a.elapsedMs == b.elapsedMs) {
            return 0;
        }
        return -1;
    })
    for (let result of results) {
        console.log(result);
    }
});

```

## Previous Activities

```javascript
// Get profile data for a particular rider (requires Zwift player id)
var profile = account.getProfile(playerId);

// Get the list of previous activities
// (start, limit parameters for paging - e.g. (0,30) for first 30 activities)
profile.activities(start, limit).then(activities => {
    console.log(activities); // JSON array of activities
});

// Get full position data for an activity from FIT file
// (translated back into Zwift world coordinates)
account.getActivity(playerId).get(activityId).then(activity => {
    console.log(activity); // JSON of activity including positions
});

```

repository: Ogadai/zwift-mobile-api

repo_name: Ogadai/zwift-mobile-api