text:
[![Latest Stable Version]](https://packagist.org/packages/wikimedia/composer-merge-plugin) [![License]](https://github.com/wikimedia/composer-merge-plugin/blob/master/LICENSE)
[![Build Status]](https://github.com/wikimedia/composer-merge-plugin/actions/workflows/CI.yaml)
[![Code Coverage]](https://scrutinizer-ci.com/g/wikimedia/composer-merge-plugin/?branch=master)

Composer Merge Plugin
=====================

Merge multiple composer.json files at [Composer] runtime.

Composer Merge Plugin is intended to allow easier dependency management for
applications which ship a composer.json file and expect some deployments to
install additional Composer managed libraries. It does this by allowing the
application's top level `composer.json` file to provide a list of optional
additional configuration files. When Composer is run it will parse these files
and merge their configuration settings into the base configuration. This
combined configuration will then be used when downloading additional libraries
and generating the autoloader.

Composer Merge Plugin was created to help with installation of [MediaWiki]
which has core library requirements as well as optional libraries and
extensions which may be managed via Composer.

Installation
------------

Composer Merge Plugin 1.4.x (and older) requires Composer 1.x.

Composer Merge Plugin 2.0.x (and newer) is compatible with both Composer 2.x and 1.x.

```
$ composer require wikimedia/composer-merge-plugin
```

### Upgrading from Composer 1 to 2

If you are already using Composer Merge Plugin 1.4 (or older) and you are updating the plugin to 2.0 (or newer), it is recommended that you update the plugin first using Composer 1.

If you update the incompatible plugin using Composer 2, the plugin will be ignored:

> The "wikimedia/composer-merge-plugin" plugin was skipped because it requires a Plugin API version ("^1.0") that does not match your Composer installation ("2.0.0"). You may need to run composer update with the "--no-plugins" option.

Consequently, Composer will be unaware of the merged dependencies and will remove them requiring you to run `composer update` again to reinstall merged dependencies.

Usage
-----

```json
{
    "require": {
        "wikimedia/composer-merge-plugin": "dev-master"
    },
    "extra": {
        "merge-plugin": {
            "include": [
                "composer.local.json",
                "extensions/*/composer.json"
            ],
            "require": [
                "submodule/composer.json"
            ],
            "recurse": true,
            "replace": false,
            "ignore-duplicates": false,
            "merge-dev": true,
            "merge-extra": false,
            "merge-extra-deep": false,
            "merge-replace": true,
            "merge-scripts": false
        }
    }
}
```

### Updating sub-levels `composer.json` files

In order for Composer Merge Plugin to install dependencies from updated or newly created sub-level `composer.json` files in your project you need to run the command:

```
$ composer update
```

This will [instruct Composer to recalculate the file hash](https://getcomposer.org/doc/03-cli.md#update) for the top-level `composer.json` thus triggering Composer Merge Plugin to look for the sub-level configuration files and update your dependencies.

Plugin configuration
--------------------

The plugin reads its configuration from the `merge-plugin` section of your
composer.json's `extra` section. An `include` setting is required to tell
Composer Merge Plugin which file(s) to merge.

### include

The `include` setting can specify either a single value or an array of values.
Each value is treated as a PHP `glob()` pattern identifying additional
composer.json style configuration files to merge into the root package
configuration for the current Composer execution.

The following sections of the found configuration files will be merged into
the Composer root package configuration as though they were directly included
in the top-level composer.json file:

* [autoload](https://getcomposer.org/doc/04-schema.md#autoload)
* [autoload-dev](https://getcomposer.org/doc/04-schema.md#autoload-dev)
  (optional, see [merge-dev](#merge-dev) below)
* [conflict](https://getcomposer.org/doc/04-schema.md#conflict)
* [provide](https://getcomposer.org/doc/04-schema.md#provide)
* [replace](https://getcomposer.org/doc/04-schema.md#replace)
  (optional, see [merge-replace](#merge-replace) below)
* [repositories](https://getcomposer.org/doc/04-schema.md#repositories)
* [require](https://getcomposer.org/doc/04-schema.md#require)
* [require-dev](https://getcomposer.org/doc/04-schema.md#require-dev)
  (optional, see [merge-dev](#merge-dev) below)
* [suggest](https://getcomposer.org/doc/04-schema.md#suggest)
* [extra](https://getcomposer.org/doc/04-schema.md#extra)
  (optional, see [merge-extra](#merge-extra) below)
* [scripts](https://getcomposer.org/doc/04-schema.md#scripts)
  (optional, see [merge-scripts](#merge-scripts) below)

### require

The `require` setting is identical to [`include`](#include) except when
a pattern fails to match at least one file then it will cause an error.

### recurse

By default the merge plugin is recursive; if an included file has
a `merge-plugin` section it will also be processed. This functionality can be
disabled by adding a `"recurse": false` setting.

### replace

By default, Composer's conflict resolution engine is used to determine which
version of a package should be installed when multiple files specify the same
package. A `"replace": true` setting can be provided to change to a "last
version specified wins" conflict resolution strategy. In this mode, duplicate
package declarations found in merged files will overwrite the declarations
made by earlier files. Files are loaded in the order specified by the
`include` setting with globbed files being processed in alphabetical order.

### ignore-duplicates

By default, Composer's conflict resolution engine is used to determine which
version of a package should be installed when multiple files specify the same
package. An `"ignore-duplicates": true` setting can be provided to change to
a "first version specified wins" conflict resolution strategy. In this mode,
duplicate package declarations found in merged files will be ignored in favor
of the declarations made by earlier files. Files are loaded in the order
specified by the `include` setting with globbed files being processed in
alphabetical order.

Note: `"replace": true` and `"ignore-duplicates": true` modes are mutually
exclusive. If both are set, `"ignore-duplicates": true` will be used.

### merge-dev

By default, `autoload-dev` and `require-dev` sections of included files are
merged. A `"merge-dev": false` setting will disable this behavior.

### merge-extra

A `"merge-extra": true` setting enables the merging the contents of the
`extra` section of included files as well. The normal merge mode for the extra
section is to accept the first version of any key found (e.g. a key in the
master config wins over the version found in any imported config). If
`replace` mode is active ([see above](#replace)) then this behavior changes
and the last key found will win (e.g. the key in the master config is replaced
by the key in the imported config). If `"merge-extra-deep": true` is specified
then, the sections are merged similar to array_merge_recursive() - however
duplicate string array keys are replaced instead of merged, while numeric
array keys are merged as usual. The usefulness of merging the extra section
will vary depending on the Composer plugins being used and the order in which
they are processed by Composer.

Note that `merge-plugin` sections are excluded from the merge process, but are
always processed by the plugin unless [recursion](#recurse) is disabled.

### merge-replace

By default, the `replace` section of included files are merged.
A `"merge-replace": false` setting will disable this behavior.

### merge-scripts

A `"merge-scripts": true` setting enables merging the contents of the
`scripts` section of included files as well. The normal merge mode for the
scripts section is to accept the first version of any key found (e.g. a key in
the master config wins over the version found in any imported config). If
`replace` mode is active ([see above](#replace)) then this behavior changes
and the last key found will win (e.g. the key in the master config is replaced
by the key in the imported config).

Note: [custom commands][] added by merged configuration will work when invoked
as `composer run-script my-cool-command` but will not be available using the
normal `composer my-cool-command` shortcut.

Running tests
-------------

```
$ composer install
$ composer test
```

Contributing
------------

Bug, feature requests and other issues should be reported to the [GitHub
project]. We accept code and documentation contributions via Pull Requests on
GitHub as well.

- [PSR-2 Coding Standard][] is used by the project. The included test
  configuration uses [PHP_CodeSniffer][] to validate the conventions.
- Tests are encouraged. Our test coverage isn't perfect but we'd like it to
  get better rather than worse, so please try to include tests with your
  changes.
- Keep the documentation up to date. Make sure `README.md` and other
  relevant documentation is kept up to date with your changes.
- One pull request per feature. Try to keep your changes focused on solving
  a single problem. This will make it easier for us to review the change and
  easier for you to make sure you have updated the necessary tests and
  documentation.

License
-------

Composer Merge plugin is licensed under the MIT license. See the
[`LICENSE`](LICENSE) file for more details.

---
[Composer]: https://getcomposer.org/
[MediaWiki]: https://www.mediawiki.org/wiki/MediaWiki
[GitHub project]: https://github.com/wikimedia/composer-merge-plugin
[PSR-2 Coding Standard]: https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-2-coding-style-guide.md
[PHP_CodeSniffer]: http://pear.php.net/package/PHP_CodeSniffer
[Latest Stable Version]: https://img.shields.io/packagist/v/wikimedia/composer-merge-plugin.svg?style=flat
[License]: https://img.shields.io/packagist/l/wikimedia/composer-merge-plugin.svg?style=flat
[Build Status]: https://github.com/wikimedia/composer-merge-plugin/actions/workflows/CI.yaml/badge.svg
[Code Coverage]: https://img.shields.io/scrutinizer/coverage/g/wikimedia/composer-merge-plugin/master.svg?style=flat
[custom commands]: https://getcomposer.org/doc/articles/scripts.md#writing-custom-commands

repository: wikimedia/composer-merge-plugin

gha_language: PHP

repo_name: wikimedia/composer-merge-plugin


text:
# Changelog
All notable changes to this project will be documented in this file.

The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).

[//]: # (- Track unreleased changes here. When you're ready to release a new version, move these tracked changes over to that version.)
## [Unreleased]
[//]: # (- List what new stuff you've added since the last version.)
### Added
[//]: # (- List what sort of changes you've made since the last version.)
### Changed
[//]: # (- Was something broken and then fixed? List it here!)
### Fixed
[//]: # (- List what old stuff you've removed since the last version.)
### Removed

[//]: # (- When you're ready to release a new version, use semantic versioning — i.e., [1.5.4] - 2018-01-20 — and migrate everything over from the Unreleased section.)
## [MAJOR.MINOR.PATCH] - YYYY-MM-DD

license: MIT

repository: dreamistlabs/dlabs-cli

branch_name: refs/heads/master

extension: md

gha_language: JavaScript

gha_license_id: MIT

license_type: permissive

repo_name: dreamistlabs/dlabs-cli


text:
---
layout: post
title: SQL Injections
date: May 17, 2014
category: code
comments: true
customid: week7technical
---
SQL injection is the use of code to exploit security vulnerabilities of SQL databases to manipulate or exploit the data that lies within the database. Successful malicious attempts of SQL injections can read sensitive data from the database, modifying database data using SQL commands like insert, update, or delete, as well as execute administration operations on the database. With these SQL injections, attackers can spoof identity or tamper with existing data such as voiding transaction or changing balances, disclosure all data on the system, or blatantly destroying all the data.

Here are some simple SQL statements that have been used as implemented in the past.

```
' or '1'='1' -- ' or '1'='1' ({ ' or '1'='1' /*
````
Here are some simple SQL statements that have been used as implemented in the past.

```
SELECT * FROM users WHERE name = '' OR '1'='1';
SELECT * FROM users WHERE name = '' OR '1'='1' -- ';
```
This statement would always render true, allowing possible spoof of identity in a user login input field.
Another simple SQL command is

```
';DROP TABLE users; SELECT * FROM userinfo WHERE 't' = 't
```
If this SQL injection was successful you could completely delete a database.

One of the things you can do to prevent SQL injections from occurring with against your databases is to use prepared statements and parameterized queries. These are SQL statements that sent and parse by the database server separate from any parameters. This allows you separate your actual SQL separate from the parameters. Any parameters you send when using the prepared statement would be separated into a string so that the search would search the entire string for the parameter input.

For example, notice that the follow user input is an entire string when sent with a prepared statement.

```
'Sarah'; DELETE FROM employees
SELECT * FROM users WHERE name = "'Sarah'; DELETE FROM employees";
```


text:
---
date: "2017-07-09"
title: "Maps and map projections"
summary: "The impossible flattening of the Earth"

tags: ["GIS", "maps", "D3"]

image:
  placement: 1
  focal_point: "Center"
  preview_only: true
---
The following are some maps I coded and of which I am very proud of.

Maps in [D3.js][d3] via my [bl.ocks][egists]:

* [Boetti][boetti]
  ![Boetti](boetti-d3.png)
* [Flags of the USA][usaflags]
  ![Flags of the USA](usa-flags-d3.png)
* Earth in a Cube [I][cube1], [II][cube2] and [III][cube3]
  ![Earth in a cube](earth-in-a-cube-3.png)
* [Cahill-Keyes map projection][ck]
  ![Cahill-Keys](ck-d3.png)

[egists]: <https://bl.ocks.org/espinielli> "Enrico Spinielli's blocks"
[d3]: <//d3js.org> "D3.js"
[usaflags]: <https://bl.ocks.org/espinielli/78185d7b29948d105634beb7bcc0d34b> "Flags of the USA"
[boetti]: <https://bl.ocks.org/espinielli/9ea56e041f6847dbe944> "Boetti's map in D3.js"
[cube1]: <https://bl.ocks.org/espinielli/1018c88657010f8ee93ea4224652e3cf> "Earth in a cube, 1"
[cube2]: <https://bl.ocks.org/espinielli/0c130de06ee3c01c0a63ba9ce06bc7bd> "Earth in a cube, 2"
[cube3]: <https://bl.ocks.org/espinielli/cf662b91b58da57aecc8125649d84604> "Earth in a cube, 3"
[ck]: <https://bl.ocks.org/espinielli/5689783> "Cahill-Keyes map projection in D3.js"


text:
# PN1280

<PageHeader />

## Description

Make the IF command case insensitive.

## Previous Release Behavior

For example:

```
if A = 10 G 1000
```

would produce an 'Invalid statement` error.

## Current Release Behavior

The IF command can be specified in any case, e.g. if, IF iF, If

This change also allows the IFN statement to be case insensitive.

Back to [5.8.3 Release Notes](./../README.md)

<PageFooter />

repository: patpog/docs

repo_name: patpog/docs


text:
auto-config-eslint-for-prettier

A cli tool to correctly configure ESLint to work with Prettier.

  Key Features •
  How To Use •
  Credits •
  Features Under Development •
  License

## Motivation

There is a lot of confusion about how to get [Prettier](https://prettier.io/)
and [ESLint](https://eslint.org/) to work together. I wanted to create a tool
that will automagically implement the recommended configurations of ESLint to
work with Prettier. I also wanted it to work similar to `eslint --init`

To start with, the only mention ESLint makes of Prettier is on their GitHub
page's
[FAQ Section](https://github.com/eslint/eslint#does-prettier-replace-eslint),
but no further directions.

Prettier makes
[two methodologies](https://prettier.io/docs/en/integrating-with-linters.html)
available to integrate with ESLint, but one
[isn't recommended](https://prettier.io/docs/en/integrating-with-linters.html#notes).
Furthermore, the suggested
[additional package](https://github.com/prettier/eslint-config-prettier)
requires configurations of the `.eslintrc.*` file mentioned in the
[instructions](https://github.com/prettier/eslint-config-prettier#installation)!

This is a bunch of steps that can and now is automated.

## Key Features

- Updates .eslintrc.js file with correct prettier extends for known plugins
  - supports the following plugins
    - `@typescript-eslint/eslint-plugin`
    - `eslint-plugin-babel`
    - `eslint-plugin-flowtype`
    - `eslint-plugin-prettier`
    - `eslint-plugin-react`
    - `eslint-plugin-standard`
    - `eslint-plugin-unicorn`
    - `eslint-plugin-vue`
- Determines and installs missing npm packages for the configuration of ESLint
  - prettier
  - eslint-config-prettier

## How To Use

1. If you haven't already, create a `.eslintrc.js` file manually or run
   `npx eslint --init`
2. run `npx auto-config-eslint-for-prettier`

## Credits

This software uses the following open source packages:

### Dependencies

- [axios](https://www.npmjs.com/package/axios)
- [cross-spawn](https://www.npmjs.com/package/cross-spawn)
- [js-yaml](https://www.npmjs.com/package/js-yaml)
- [Prompts](https://www.npmjs.com/package/prompts)
- [stringify-object](https://www.npmjs.com/package/stringify-object)

### Development Dependencies

- [Chai](https://www.npmjs.com/package/chai)
- [ESLint](https://www.npmjs.com/package/eslint)
- [chai-as-promised](https://www.npmjs.com/package/chai-as-promised)
- [coveralls](https://www.npmjs.com/package/coveralls)
- [eslint-config-airbnb-base](https://www.npmjs.com/package/eslint-config-airbnb-base)
- [eslint-config-prettier](https://www.npmjs.com/package/eslint-config-prettier)
- [eslint-plugin-import](https://www.npmjs.com/package/eslint-plugin-import)
- [eslint-plugin-jsdoc](https://www.npmjs.com/package/eslint-plugin-jsdoc)
- [Generate Changelog](https://www.npmjs.com/package/generate-changelog)
- [Husky](https://www.npmjs.com/package/husky)
- [Mocha](https://www.npmjs.com/package/mocha)
- [Node.js](https://nodejs.org/)
- [nyc](https://www.npmjs.com/package/nyc)
- [Prettier](https://www.npmjs.com/package/prettier)
- [Sinon.js](https://www.npmjs.com/package/sinon)

## Features Under Development

- [x] Detect if ESLint isn't setup yet
- [x] Support eslintrc in YAML format
- [x] Support eslintrc in JSON format
- [x] Optionally auto install of Prettier and/or eslint-config-prettier
- [x] Add ability to download json(c) rules, from pre-defined keywords
- [ ] Add ability to download json(c) rules, from arbitrary URLs
- [ ] Add ability to read json(c) rules, from a local path

## License

MIT

---

> [aaronyoung.dev](https://aaronyoung.dev)  ·  GitHub
> [@brainomite](https://github.com/brainomite)

branch_name: refs/heads/main


text:
# sovrin-client-rust

# Windows build

- Get binary dependencies (libamcl*, openssl, libsodium, libzmq, sqlite3).
- Put all *.{lib,dll} into one directory and headers into include/ subdirectory.
- open MSVS development console
- execute "C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvars64.bat"
- Point path to this directory using environment variables:
  - set SOVRIN_PREBUILT_DEPS_DIR=C:\BIN\x64
  - set SODIUM_LIB_DIR=C:\BIN\x64
  - set OPENSSL_INCLUDE_DIR=C:\BIN\x64\include
  - set OPENSSL_LIB_DIR=C:\BIN\x64
  - set LIBZMQ_LIB_DIR=C:\BIN\x64
  - set LIBZMQ_INCLUDE_DIR=C:\BIN\x64\include
- set static flag for libsodium build
  - set SODIUM_STATIC=y
- change dir to sovrin-client and run cargo (you may want to add --release --target x86_64-pc-windows-msvc keys to cargo)

## openssl-sys workaround

When your windows build fails complaining on gdi32.lib you should edit

```
  ~/.cargo/registry/src/github.com-*/openssl-sys-*/build.rs
```

and add

```
  println!("cargo:rustc-link-lib=dylib=gdi32");
```

to the end of main() function.

Then try to rebuild whole project.

repository: peacekeeper/sovrin-client-rust

repo_name: peacekeeper/sovrin-client-rust


text:
Rocky Tools
===========

Various scripts and tools that we find useful, whether we use them or they are
made for public consumption.

## [migrate2rocky](./migrate2rocky/) -- Conversion Script

Running this script will convert an existing CentOS 8 system to Rocky Linux 8.

## [mirrorsync](./mirror/) -- Mirror Script

Example script for keeping a public or private mirror in sync.


text:
---
layout: process
title: M.A.G //004
category: M.A.G
subcategory:
description: Spatial Analysis & Simulation // ML & Sensors
dependencies: [ 'Lines' ]
platforms: [ 'Rhinoceros','Grasshopper' ]
heroimg: ITL-01.jpg
order: 4
thumb: thumb.png
---

## Spatial Analysis & Simulation // ML & Sensors
---

![splash](./images/splash.jpg)

The primary focus of this research is *spatial prospecting - to collect, analyze, and mine spatial data* to reveal human macro and micro structures hidden deep in our spatial and temporal dimensions. We are developing novel ways to combine machine learning, computer vision, photogrammetry, IoT devices, industrial design, architecture, and urban design, to allow us to gain insights into the relationship between space, design, and human behavior. There are several research areas that are currently undertaken by MAG under this topic., each with its own subset of challenges and goals.

We have categorized our research areas into two domains: Public and Private. Public space analytics prioritizes itself with gathering anonymous spatial data in both urban and indoor environments, so we can gain insight into how design can facilitate social interactions. Private space analytics, on the other hand, is predicated on the use of data to help facilitate planning and management.

------

### Spatial Analytics with Machine Learning

This research proposes a fully automated, autonomous, and anonymous approach to spatial and behavioral tracking using uncalibrated and unordered video footage and Building Information Models. The proposed technology allows us to utilize video recordings from most existing security camera systems and extract information on how people interact with objects in space, and their tendencies to congregate in certain areas. The spatial and behavioral tracking and analysis uses state of the art machine learning algorithm in human detection to produce a 3-dimensional point cloud dataset which can then be visualized as a heatmap for understanding activity concentrations.

We also extract data for body gestures and how people interact with objects such as urban furniture, sculptures, lawn, trees, and other types of urban objects.  The system targets the archaic practice in urban design and architecture where spatial usage pattern data is collected with a survey by hand and on foot, which leads to highly inaccurate, unintelligibly biased, and practically useless results.

------

### Space Occupancy Tracking

This research proposes an automated space occupancy tracking system to correlate spatial and behavioral analytics to environmental data via a network of Internet of Things (IoT) devices. The research  addresses one of the fundamental issues of any facilities which is how to enhance people's emotional and  physical productivity while effectively maximizing spatial occupancy with adequate infrastructure. The system uses machine learning human detection to collect anonymous spatial and behavioral data, custom trained machine learning object detection algorithm for furniture location and orientation detection, an Internet of Things sensor network for environmental data collection to gather temperature, humidity, light level, air quality, and lastly, a stereo camera with structure from motion algorithm for near realtime 3-dimensional point-cloud generation.

Below is a video showing test results of our custom trained machine learning tags. The tags will be deployed on furnitures and this setup will allow us to track location and orientation of the furnishings, as well as how people interact with them.

------

### Sensor Modules Design

One of our main goals is to pursue this as an interdisciplinary research and involve as many research assisants from different disciplines as possible. For our sensor network, the immediate design challenge is to develop a proper housing that can facilitate air flow and heat dissipation, battery and port access, and last but not least, mounting and structural issues, all the while keeping the design as compact and portable as possible.

An example design of our sensor network modules, designed and prototyped by our research assistant from the Industrial Design Department.

    Machine Learning Computer Vision

    Environmental Sensor Pack

    Stereo SLAM Realtime 3D Capture

------

### Structure from Motion Photogrammetry

Below is an example of a 3D scan with SfM camera setup. Our approach is to combine high resolution data used to capture "Hard Elements" such as the locations of high wired infrastructure, building structure, and equipment. These are the static objects that do not or cannot be changed.  This high resolution scan can be used in conjunction with low-resolution real-time 3D scanning technology such as SLAM (see below) to assess the "Soft Elements" such as the presence and location of objects, furnitures, or anything else that maybe out-of-place.

This space is our ITL office in Brooklyn. Annotations in the model show the location of the sensors currently setup in our space. And the graphs below show the reading of our sensors.

------

### Data Visualization

We are also developing a dashboard system that can display all the relevant data gathered from the sensor network, machine learning spatial and behavioral tracking data, along with the 3D and 2D information. This allows us to run analytics and assessments to quantify all of these values as a comprehensive dataset.

Room Occupancy Map

ggg

------

### Stereo Simultaneous Localization and Mapping Tests

We are conducting tests using stereocamera setup to generate realtime 3D scans. A stereocamera is mounted onto a robotic arm to sweep in a controlled and pre-defined path.

Mock up of a low resolution SLAM model, which can be used to assess soft elements such as any objects that are occupying the room that are not hard wired to the building.

---

repository: pratt-itl/MAG

gha_license_id: NOASSERTION

repo_name: pratt-itl/MAG


text:
# Script to post Aditya's face on Instagram every day (only if he forgets)
Mark Zuckerberg smells bad and doesn't support posting images through the official Instagram API, but it's possible to spook the request by identifying as a version 4 Instagram client.
The script checks every day at 11:59 if a picture has been posted, otherwise it will post.

### Installation
```
Linux/Debian:
git clone https://github.com/andrewhu/dirtydeetz.git
chmod 755 dirtydeetz && chmod 644 dirtydeetz/*
cd dirtydeetz && php dirtydeetz.php
```
### Scheduling a crontab (automated task)
Open the crontab file:
```
crontab -e
```
Add this line to the crontab file:
```
# .---------------- minute (0 - 59)
# |  .------------- hour (0 - 23)
# |  |   .---------- day of month (1 - 31)
# |  |   |  .------- month (1 - 12) OR jan,feb,mar,apr ...
# |  |   |  |  .---- day of week (0 - 6) (Sunday=0 or 7)  OR sun,mon,tue,wed,thu,fri,sat
# |  |   |  |  |
# *  *   *  *  *  command to be executed

  59 23  *  *  *  php /my/name/is/jeff/dirtydeetz.php
```

A `*` denotes running every time, e.g. a `*` in the hour field will run the script every hour. The example above will run `dirtydeetz.php` at 23:59 (11:59 PM) every day of the month, every month, every day of the week.
### Reminders
- Remember to set the correct timezone on the machine you are running

## Example
https://instagram.com/samepictureofdirtydeetz


text:
# Disaster Response Pipeline Project
### Table of Contents

1. [Introduction](#introduction)
2. [Descriptions](#descriptions)
3. [Getting Started](#getting_started)
4. [Acknowledgements](#acknowledgements)

## Introduction
Following a disaster, disaster response organizations typically receive millions of messages either directly or via social media. At those moments, the disaster response organizations normally lack resources to handle the vast amount of information: to filter and select the most information.

Within a disaster response organization, a different part of taking care of different parts of the problem: one takes care of water, another takes care of blocked roads, and another will be responsible for medical supplies. Therefore an automated workflow that efficiently processes the received messages will be beneficial to direct it to the responsible party.

In this project, we will use prelabeled tweets and text messages to train a machine learning model that is capable of classifying text messages.

## Description
The Project is divided in the following sections:

- ETL Pipeline: extract, clean data and stores the data;
- ML Pipeline: train a model that works to classify text messages;
- Web App: classify the real time input text messages

## Getting Started
### Dependences

### Folder Structure
```
├── LICENSE
├── README.md
├── app
│   ├── run.py  # Flask file that runs the app
│   └── templates
│       ├── go.html # web page contains the classification result
│       └── master.html # main page of web app
├── data
│   ├── DisasterResponse.db # database stores the processed data
│   ├── disaster_categories.csv
│   ├── disaster_messages.csv
│   └── process_data.py # scripts to clean and store the text messages
├── models
│   └── train_classifier.py # scripts to train the classifier
└── notebooks
    ├── ETL Pipeline Preparation.ipynb
    └── ML Pipeline Preparation.ipynb
```
### How To:
1. Run the following commands in the project's root directory to set up your database and model.

    - To run ETL pipeline that cleans data and stores in database
        `python data/process_data.py data/disaster_messages.csv data/disaster_categories.csv data/DisasterResponse.db`
    - To run ML pipeline that trains classifier and saves
        `python models/train_classifier.py data/DisasterResponse.db models/classifier.pkl`

2. Run the following command in the app's directory to run your web app.
    `python run.py`

3. Go to http://<IP_ADDRESS>:3001/

## Acknowledgements

- [Figure Eight](https://www.figure-eight.com) provided the prelabeled tweets and text messages used for model training

## Futures
Areas to further optimize in the future:

- Improve visualizations to the web app.
- Customize the design of the web app.
- Deploy the web app to a cloud service provider.
- Improve the efficiency of the code in the ETL and ML pipeline.
- Optimize the model to better handle imbalanced input
- EDA to further analyze data categories.

## Contact
[Jinchao<EMAIL_ADDRESS>


text:
# Restful chinook
## (Muziek-project)
...

---

## User Story Dependencies

![Story Dependency Diagram](https://github.com/bermarte/Restful-chinook/blob/main/project-planning/user%20story.png?raw=true)

---

## WIREFRAME

![wireframe1](https://github.com/bermarte/Restful-chinook/blob/main/project-planning/login.png?raw=true)
![wireframe2](https://github.com/bermarte/Restful-chinook/blob/main/project-planning/wireframe.jpg?raw=true)
![design](https://github.com/bermarte/Restful-chinook/blob/main/project-planning/design.jpg?raw=true)

---

## 0.Setup
- Start a repo and clone it to directory
- Add collaborators
- Set up a project board
- Create the backlog
- Design a wireframe to set guidelines for UI/UX design.
- Devise a development strategy
- Create initial README file
- Each developed branch is merged to `master` branch after completion
---

## Back-End

- `db-connection.js` connect the database with SQLite3

### 1. User Story: Tracks
Create a fully-functioning API, routes and path:
- `/api/tracks` to view tracks data such as `TrackId`, `Name`, `AlbumId`, `MediaTypeId`, `GenreId`, `Composer`, `Milliseconds`, `Bytes`, `UnitPrice`
- `/api/tracks/search/:items`
- `/api/tracks/add`
- `controller.js`, `routes.js`, `index.js`

### 2. User Story: Playlists

Create a fully-functioning API route:
- `/api/playlist` to view `PlaylistId`, `Name`
- `controller.js`, `routes.js`, `index.js`

### 3. User Story: Albums

Create a fully-functioning API route:
- `/api/albums` to view `AlbumId`, `Title`, and `ArtistId`
- `controller.js`, `routes.js`, `index.js`

### 4. User Story: Artists

Create a fully-functioning API route:
- `/api/artists` to view `ArtistId`, `Name`
- `controller.js`, `routes.js`, `index.js`

### 5. User Story: Genres

Create a fully-functioning API route:
- `/api/genres` to view `GenreId`, `Name`
- `controller.js`, `routes.js`, `index.js`

### 6. User Story: Media-types

Create a fully-functioning API route:
- `/api/media-types` to view `MediaTypeId`, `Name`
- `controller.js`, `routes.js`, `index.js`
### 7. User Story: Sales
Create a fully-functioning API routes and path:
- `/api/sales`
- `/api/sales/country`
- `/api/sales/year`

### 8. User Story: Catalog

Create a fully-functioning API route:
- `/api/catalog`

### 9. User Story : Customers

Create a fully-functioning API routes and path:
- `/api/customers`
- `/api/customers/add`
## Front-End

- Design the wireframe with Figma
- Create accessible website built with HTML, CSS and JS
- Create input element div element for each display section
- Styling of the html document and its body styling of the background, inner content and lists (with CSS framework)

## Finishing Touch

## Deploy the App if everything are working

- Heroku
---

repository: bermarte/Restful-chinook

repo_name: bermarte/Restful-chinook


text:
Kitty Vim Tmux Navigator
==================

This plugin is a fork from [vim-kitty-navigator](https://github.com/knubie/vim-kitty-navigator) extending it's capabilities to also work with tmux pane navigation. The aim is to make navigation between Kitty windows, tmux panes, and vim splits seamless. With some extra configuration, kitty-tmux navigation works even through SSH!

**NOTE**:
- This requires kitty v0.13.1 or higher.
- Requires newer version of tmux with 'pane_at_*' format feature. (Not sure which version, but tested tmux 2.1 and didn't work)
- Works only 2 nested layer deep. So navigation for vim splits inside tmux inside kitty is not supported.

Usage
-----

This plugin provides the following mappings which allow you to move between
Vim splits, tmux panes, and kitty window seamlessly.

- `<ctrl-h>` => Left
- `<ctrl-j>` => Down
- `<ctrl-k>` => Up
- `<ctrl-l>` => Right

Installation
------------

### VIM

Use your favorite plugin manager and add the following repo to your plugin list
```vim
'NikoKS/kitty-vim-tmux-navigator'
```
And then run the plugin installation function

### KITTY

To configure kitty, do the following steps:

1. Copy both `pass_keys.py` and `neighboring_window.py` kittens to the `~/.config/kitty/`.

2. Add the following to your `~/.config/kitty/kitty.conf` file:

```sh
map ctrl+j kitten pass_keys.py bottom ctrl+j
map ctrl+k kitten pass_keys.py top    ctrl+k
map ctrl+h kitten pass_keys.py left   ctrl+h
map ctrl+l kitten pass_keys.py right  ctrl+l
```

`kitty-vim-tmux-navigator` changes `vim-kitty-navigator` vim detection method from using title name to running foreground process name. So it removes the capability to change title regex.

3. Enable kitty `allow_remote_control` and `listen_on` option:

Set it on the `~/.config/kitty/kitty.conf` file:

```conf
allow_remote_control yes
listen_on unix:/tmp/mykitty
```

**OR**

Start kitty with the `listen_on` option so that vim can send commands to it.

```
kitty -o allow_remote_control=yes --listen-on unix:/tmp/mykitty
```

The listening address can be customized in your vimrc by setting `g:kitty_navigator_listening_on_address`. It defaults to `unix:/tmp/mykitty`.

### TMUX

If you're using [TPM](https://github.com/tmux-plugins/tpm), just add this snippet to your tmux.conf:

```conf
set -g @plugin 'NikoKS/kitty-vim-tmux-navigator'
```

And update your plugin

**Otherwise**

Add the following snippet to your tmux.conf:

```sh
# SSH aware kitty change window
if-shell '[ $SSH_TTY ]' 'to="--to=tcp:localhost:$KITTY_PORT "' 'to=""'
move='kitty @ ${to}kitten neighboring_window.py'

# Key Binds
bind-key -n 'C-h' if-shell "[ #{pane_at_left} != 1 ]" "select-pane -L" "run-shell '$move left'"
bind-key -n 'C-j' if-shell "[ #{pane_at_bottom} != 1 ]" "select-pane -D" "run-shell '$move bottom'"
bind-key -n 'C-k' if-shell "[ #{pane_at_top} != 1 ]" "select-pane -U" "run-shell '$move top'"
bind-key -n 'C-l' if-shell "[ #{pane_at_right} != 1 ]" "select-pane -R" "run-shell '$move right'"
```

SSH Compatibility
-----------------

With the settings above, navigation should work well locally. But if you need kitty-tmux navigation also work through ssh, follow steps below:

1. Install kitty on your remote machine. [How To](https://sw.kovidgoyal.net/kitty/binary.html?highlight=install).
With kitty installed on your remote system and remote control enabled, you should be able to use remote control from ssh. But because of reasons explained [here](https://github.com/kovidgoyal/kitty/issues/2338), it won't work from inside tmux. So we're going to need some workarounds.

2. Set remote port forwarding when using SSH.

```sh
ssh -R 50000:${KITTY_LISTEN_ON#*:} user@host
```

The remote TCP port 50000 can be changed to anything depending on your needs.

You can put it as an alias on your shell rc file so you don't type it all the time.

```sh
alias ssh='ssh -R 50000:${KITTY_LISTEN_ON#*:}'
```

3. Add the following snippet to your remote machine's `.bashrc` or something similar on other shell:

```sh
# Source kitty binary
export PATH=$PATH:~/.local/kitty.app/bin/

# Set KITTY_PORT env variable
if [[ $SSH_TTY ]] && ! [ -n "$TMUX" ]; then
  export KITTY_PORT=`kitty @ ls 2>/dev/null | grep "[0-9]:/tmp/mykitty" | head -n 1 | cut -d : -f 1 | cut -d \" -f 2`
fi

# Kitty Terminal Navigation
bind -x '"\C-h": kitty @ kitten neighboring_window.py left'
bind -x '"\C-j": kitty @ kitten neighboring_window.py top'
bind -x '"\C-k": kitty @ kitten neighboring_window.py bottom'
bind -x '"\C-l": kitty @ kitten neighboring_window.py right'
```

  **Explanation**:
- Source kitty path so the binary can be called from anywhere
- Set the KITTY_PORT environment variable automatically from the foreground process that call ssh.
- Set terminal key binding for changing kitty window when not using tmux

4. Don't forget to install the tmux plugin on your remote system also. And copy `neighboring_window.py` to your remote machine ~/.config/kitty directory.

repository: NikoKS/kitty-vim-tmux-navigator

repo_name: NikoKS/kitty-vim-tmux-navigator


text:
| Name | Institution | Status |
|---|---|---|
| Frossie Economou | LSST | Accepted |
| August Muench | AAS | Accepted |
| Josh Peek | StSci | Accepted |
| Britton Smith | SDSC | Accepted |
| Matthew Turk | UIUC | (WT) |
| Nathan Goldbaum | UIUC | Accepted |
| Sarah Loebman | UC Davis | Accepted |

  Meeting Records
  31 May 2017. Attending: Frossie, Josh, Matt. Discussion around high-level
  architecture, API, and so on.  Vision description was conveyed.  Feedback
  provided was around the notion of data access abstraction being
  high-priority.  Some particular questions were around access privs for data,
  production-readiness, and deployments.

repository: aprilcs/whole-tale

repo_name: aprilcs/whole-tale


text:
OpenShift
---------

Red Hat® [OpenShift](https://www.openshift.com/) is a container application platform that brings docker and Kubernetes to the enterprise.

 You can try out OpenShift or develop with it, day-to-day, on your local host.

MiniShift Umgebung mit OpenShift anlegen. Erzeugt eine VM mit OpenShift darin.

	minishift start --vm-driver=virtualbox

`oc` aktiveren

	export PATH=/c/Users/mbern/.minishift/cache/oc/v3.6.0/:$PATH

	oc login -u system:admin
	oc status

#### Links

* [Doku](https://docs.openshift.org/latest/minishift/index.html)

### OC

The OpenShift CLI (oc) exposes commands for managing your applications, as well as lower level tools to interact with each component of your system.

#### Links

* [Doku](https://docs.openshift.com/enterprise/3.0/cli_reference/get_started_cli.html)

repository: mc-b/devops

repo_name: mc-b/devops


text:
# AutomaticRecordingResource

## Properties

Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**Enabled** | **bool** | Flag for controling Automatic Call Recording settings | [optional]
**OutboundCallTones** | **bool** | Flag for controlling 'Play Call Recording Announcement for Outbound Calls' settings | [optional]
**OutboundCallAnnouncement** | **bool** | Flag for controlling 'Play periodic tones for outbound calls' settings | [optional]
**AllowMute** | **bool** | Flag for controlling 'Allow mute in auto call recording' settings | [optional]
**ExtensionCount** | **int32** | Total amount of extension that are used in call recordings | [optional]

[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

repository: Brutalbeard/go-ringcentral

repo_name: Brutalbeard/go-ringcentral


text:
---
title: "Persistent multi-user Docker on macOS"
date: 2021-02-01
description: "First, be aware that docker is not designed to be securely shared among multiple users. Please assume..."
slug: shared-docker-mac
main_image: https://dev-to-uploads.s3.amazonaws.com/i/movf3eo57f8rvpeqgjty.jpg
tags:
 - tech

---

Need to make Docker on macOS available to any user who connects in remotely? It can be done!

First, be aware that `docker` is not designed to be securely shared among multiple users. Please assume that anyone who has access to `docker` is effectively equivalent to `root'.

This assumes that users will be interacting with `docker` via the command-line, rather than graphically. It also assumes that the environment is such that allows a single user to be automatically logged into via the GUI, but this is mostly out of laziness rather than an underlying technical restriction.

1. Choose an account that Docker Desktop will run as. I recommend creating a `docker` user, but it could be any account. This account does not need admin access.

2.  Open `Settings -> Users & Groups -> Login Options`, and ensure that this user is automatically logged into.

3. Created a shared containers directory:

```shell
sudo mkdir -p /Users/Shared/Library/Containers
sudo chown docker:staff /Users/Shared/Library/Containers
sudo chmod -R 770 /Users/Shared/Library/Containers/
```

4. Login graphically with the account that will run Docker and start `/Applications/Docker.app`, answer any questions it might have.
5. Open `Settings -> Users & Groups -> Login Items`, and drag the `Docker` app to it.
6. Quit `Docker Desktop` via the menu item
7. Open `Terminal` and move your Docker data to a shared location that can be written to by other users:

```shell
mv ~/Library/Containers/com.docker.docker /Users/Shared/Library/Containers
chmod -R 770 /Users/Shared/Library/Containers/com.docker.docker
chmod -R +a "group:staff allow list,add_file,search,add_subdirectory,delete_child,readattr,writeattr,readextattr,writeextattr,readsecurity,file_inherit,directory_inherit" /Users/Shared/Library/Containers/com.docker.docker
chmod -R g+rw /Users/Shared/Library/Containers/com.docker.docker/Data
```

Then link your local Docker data to this shared source, and make sure that others can traverse into this folder to resolve the socket symlink:

```shell
ln -s /Users/Shared/Library/Containers/com.docker.docker ~/Library/Containers/com.docker.docker
chmod g+x ~/Library ~/Library/Containers
```

6. Restart `/Applications/Docker.app` to test
7. SSH into the host as another username, and run `docker run mariadb` to test.
8. Reboot host and reconnect via ssh to test (it may take a moment for Docker to start up)

This is the configuration we use for the #kernelcafe. Please add your improvements to the comments!


text:
# react-search

[![npm version](https://badge.fury.io/js/react-search.svg)](https://badge.fury.io/js/react-search)
[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat)](https://github.com/feross/standard)

react-search is a simple search autocomplete component using react.js.

## Installation

`npm install react-search --save`

## Usage

```jsx

import Search from 'react-search'
import ReactDOM from 'react-dom';
import React, { Component } from 'react';

let ITEMS = ['ruby', 'javascript', 'lua', 'go', 'julia', 'c', 'scala','haskell']

ReactDOM.render(<Search items={ITEMS}/>, document.getElementById('root'));

```

## Basic Props

#### `items` (required)
List of Items to filter through

#### `classPrefix`
default: `react-search`
Optional class prefix for included class names. Will also be attached to the main wrapper element. Included class suffixes are:
  - `__input`
  - `__menu`
  - `__menu-item`
  - `__menu--hidden`

#### `placeHolder`
Placeholder attribute for the text input

#### `onChange`
Update handler for the text input. Fired before the internal logic to update the autocomplete list

#### `onClick`
Click handler for each item in the autocomplete list. Fired before the internal logic to hide the autocomplete list

#### `ItemElement`
default: `'a'`
Custom element to use for each `<li>` in the autocomplete list. Can be a React Element or a valid DOM tag as a string, such as `<CustomElement>` or `'div'`

#### hiddenClassName
default: ``${classPrefix}__menu--hidden``
Class name override to be set when hiding the autocomplete list

#### openClassName
default: ``${classPrefix}__menu--open``
Class name override to be set when showing the autocomplete list

## Advanced Props

All of the following allow you to extend ([via spread operator](https://facebook.github.io/react/docs/transferring-props.html)) the properties of the individual elements that make up the `Search` component.

#### `inputProps`
Property extensions for the text input

#### `itemProps`
Property extensions for the each individual autocomplete `<li>`

#### `itemElemProps`
Property extensions for the each child element of autocomplete `<li>`

#### `autoCompleteListProps`
Property extensions for the autocomplete `<ul>`

#### `autoCompleteProps`
Property extensions for the autocomplete wrapper

#### `wrapperProps`
Property extensions for the wrapper that is the root of the `<Search>` component

## Callbacks onClick and onChange

You can specify callback functions for onClick of the element and onChange of the search input. The element passed in is the SyntheticKeyboardEvent, which you can use to get the target or value. Check out the [example](https://github.com/StevenIseki/react-search/tree/master/example)

## Styles

react-search can be used with your own custom styles. A minimal search.css style sheet is included in the example as a guide. The styles follow [BEM](https://en.bem.info/method/) naming conventions.

## Development
    npm install
    npm run build
    npm test
    npm start

## License

[MIT](http://isekivacenz.mit-license.org/)


text:
# gl-streaming

Streaming opengl commands over network

A fast, simple, lightweight and low latency framework suitable for embedded systems. (no X server needed)

![gl-streaming summary](https://raw.github.com/shodruky-rhyammer/gl-streaming/master/www/gl-streaming_small.png)

* gl_client : client framework and sample program

  The client system does not need to have any GPU and heavy X server. Even without GPU, opengl programs can be run on any system !

* gl_server : server framework

  gl_server is optimized for Raspberry Pi for now. Therefore, the client system can use opengl es 2.0.

## Demo Video

[Demo Video1](http://youtu.be/6S-Epb6m6mI)

[Demo Video2](http://youtu.be/y0eRwrwetcA)

## Quick start

connect RPi and the client system with a ethernet cable. (straight cable is ok)

connect RPi to a display with HDMI cable. (yes, RPi do it)

copy the gl_server directory to RPi.

``cd gl_server``

``make``

``./gl_server -s <IP_ADDRESS>:12345 -c <IP_ADDRESS>:12346``

(Usage: ./gl_server [-s my_ip_address:port] [-c client_ip_address:port])

copy the gl_client directory to any computer.

``cd gl_client``

``make``

``./sample1 -s <IP_ADDRESS>:12345 -c <IP_ADDRESS>:12346 -j /dev/input/js0``

``./sample2 -s <IP_ADDRESS>:12345 -c <IP_ADDRESS>:12346 -j /dev/input/js0``

(Usage: ./sampleX [-c my_ip_address:port] [-s server_ip_address:port] [-j joystick_device])

## License

BSD 3-Clause license (except other's source code)

about sample2 camel model:
original model from http://opengameart.org/content/camel
License:CC0 author: noway, sandsound
(Thanks for sharing!)

## Bookmarks

[Parallella](http://www.parallella.org/)

[Raspberry Pi](http://www.raspberrypi.org/)

## Special Thanks

Thank you very much for your interest and advices.

noway @opengameart.org /
sandsound @opengameart.org /
GClements @OpenGL forum /
The Little Body @OpenGL forum /
Stephen A @OpenGL forum /
over9000 @Parallella forum /
LamsonNguyen @Parallella forum /
Gravis @Parallella forum /
svartalf @Parallella forum /
Raspberry Pi Foundation /
Adapteva /

(c) Shodruky Rhyammer

since Oct 21, 2013

repository: mittorn/gl-streaming

repo_name: mittorn/gl-streaming


text:
# gh-cli-go

A github cli app for retrieving and downloading user info to local filesystem.
It also have a superb game you surely want to play with.
Check that out with `gh-cli-go play` or do `gh-cli-go help` for more information.

[![Go](https://github.com/itzmanish/gh-cli-go/actions/workflows/go.yml/badge.svg?branch=master)](https://github.com/itzmanish/gh-cli-go/actions/workflows/go.yml)
[![codecov](https://codecov.io/gh/itzmanish/gh-cli-go/branch/master/graph/badge.svg?token=RDWK10DQYI)](https://codecov.io/gh/itzmanish/gh-cli-go)
[![Go Report Card](https://goreportcard.com/badge/github.com/itzmanish/gh-cli-go)](https://goreportcard.com/report/github.com/itzmanish/gh-cli-go)

Checklist

- [x] user info
- [x] repo info
- [x] organisation info
- [x] followers
- [x] following
- [x] stars
- [x] Guess the star game
- [x] Testcases
- [x] Makefile

#### Installation Instruction

```go
go build main.go -o gh-cli-go
go install
```

#### Usages

```
gh-cli-go -h
NAME:
   gh-cli-go - A Github CLI which provides downloading users data from github.

USAGE:
   gh-cli-go [global options] command [command options] [args and such]

VERSION:
   v1.0.0

AUTHOR:
   Manish<EMAIL_ADDRESS>
COMMANDS:
   init      Initialize user with github username and token
   download  Download all information available for initialized user
   show      show all information available for initialized user
   play      play guess the star game
   help, h   Shows a list of commands or help for one command

GLOBAL OPTIONS:
   --help, -h     show help (default: false)
   --version, -v  Shows current cli version (default: false)

COPYRIGHT:
   (c) 2021 Manish
```

repository: itzmanish/gh-cli-go

repo_name: itzmanish/gh-cli-go


text:
# Git Diff Details package

View git diffs directly in atom.

Keybindings:
  * `alt-g alt-d` to toggle the diff view
  * `escape` to close the diff view
  * `alt-u` for undo
  * `alt-c` for copy

![git-diff-details](https://github.com/samu/git-diff-details/blob/master/demo.gif?raw=true)

## TODOs

- [ ] Tests!
- [x] Clean up deprecated api calls
- [x] Configuration options


text:
> [Go to French version](/fr/Règlements/Décrets,%20ordonnances%20et%20règlements%20statutaires/97/353.md)

# Indian Affairs and Northern Development Aboriginal Peoples Employment Equity Program Appointments Regulations

**SOR/97-353**

Enabling authorities:
- [PUBLIC SERVICE EMPLOYMENT ACT](/en/Acts/Statutes%20of%20Canada/2003/c.%2022,%20ss.%2012,%2013%20.md)

Date registered: 16 July 1997

----------

The Public Service Commission, pursuant to paragraph 35(2)(d)[a] of the [Public Service Employment Act](/en/Acts/Statutes%20of%20Canada/2003/c.%2022,%20ss.%2012,%2013%20.md), hereby makes the annexed Indian Affairs and Northern Development Aboriginal Peoples Employment Equity Program Appointments Regulations.

a: S.C. 1992, c. 54, s. 23

Ottawa, Ontario, July 10, 1997

## Interpretation

**1** The definitions in this section apply in these Regulations.

***aboriginal peoples*** has the same meaning as in section 3 of the [Employment Equity Act](/en/Acts/Statutes%20of%20Canada/1995/c.%2044.md). (*Autochtones*)

***employment equity program*** means a program to enhance the recruitment of aboriginal peoples to positions in the Department of Indian Affairs and Northern Development agreed to by the Public Service Commission on May 1, 1995 and March 5, 1997 at the request of the deputy head of that Department and implemented in accordance with section 5.1 of the [Public Service Employment Act](/en/Acts/Statutes%20of%20Canada/2003/c.%2022,%20ss.%2012,%2013%20.md). (*programme d’équité en matière d’emploi*)

## Exclusions

**2**

- **(1)** Subject to subsection (2), appointments of aboriginal peoples to positions in the Department of Indian Affairs and Northern Development under the employment equity program are excluded from the operation of subsections 29(3), 30(1) and (2) and 39(3) and (4) of the [Public Service Employment Act](/en/Acts/Statutes%20of%20Canada/2003/c.%2022,%20ss.%2012,%2013%20.md) and from the operation of any regulations made under paragraph 35(2)(a) of that Act.

- **(2)** Subsection (1) does not apply to aboriginal peoples with appointment priority entitlements under subsections 29(3), 30(1) and (2) and 39(3) and (4) of the [Public Service Employment Act](/en/Acts/Statutes%20of%20Canada/2003/c.%2022,%20ss.%2012,%2013%20.md) and regulations made under paragraph 35(2)(a) of that Act.

## Coming into Force

**3** These Regulations come into force on July 16, 1997.

repository: TravisMadill/CanadianLaws

path: /en/Regulations/Statutory Orders and Regulations/97/353.md

repo_name: TravisMadill/CanadianLaws


text:
+++
title="Middleware"
slug="middleware"
weight=2
+++

Middleware allows you to intercept, modify, or add behavior to your
application's request handling. You attach middleware to Boltzmann either to
your application, or to individual handlers. This allows you to modify request
handling for all, or a subset of, your handlers.

<!-- more -->

Middleware is useful for:

- **Attaching** domain-specific attributes to request context: if you were to
  build a pizza-ordering service, you might use middleware to attach
  `context.pizzaClient = new DominosAPIClient()`.
- **Intercepting** the request before it reaches the rest of your application,
  allowing you assert facts about request context that reaches your handlers.
  For example, you might have middleware that responds to any unauthenticated
  request with a 401. As a result of this hypothetical middleware, the handlers
  in your application can rely on the fact that the user is authenticated.
- **Modifying** the response from handlers in your application. For example,
  [you could implement middleware to handle `Accept-Encoding: gzip` ][ref-gzip].

Middleware is Boltzmann's primary mechanism for exposing configurable behavior
to you. It is also Boltzmann's mechanism for enabling [dependency
injection][ref-di]. It's a powerful concept! This document will cover how to
talk about middleware and how to attach it to your application. Other documents
cover how to write middleware and [what middleware boltzmann makes
available to your application][ref-reference].

> :warning: This document does not cover how to parse incoming request bodies.
> that information is available [in the "handling user input"] document.

---

## What is middleware?

Middleware is a repeatable mechanism for layering handlers and allowing them
to delegate control to inner handlers. That's kind of a mouthful!

Middleware is structured like an **onion**. A single middleware is like a layer
of the onion. When Boltzmann responds to a request, it draws a line through
that onion. Each layer may pass control to the next layer in the onion using
`next()`, or it can respond to the request directly, skipping the inner layers
of the onion. For every layer the request passes through coming in, it will
have to travel back out through in order to send a response.

  Boltzmann uses this property to let outer
layers of the application assert facts that inner layers may rely upon without
knowing _how_ those facts are asserted. Concretely: if you are using redis
middleware, every layer of your application past the redis middleware layer
may rely on the availability of `context.redisClient`, but they are _agnostic
of how that property came to exist and the concrete type to which it points._
Indeed, under test, you might cut out the redis middleware and replace it with
middleware that puts a mock redis client implementation in place!

In order to talk about how to write middleware, it is handy to have a shared
vocabulary for talking about the anatomy of a single middleware. What follows
is a TypeScript set of definitions for middleware, and an associated example.
Do not fret if you're not comfortable reading this syntax! After the
example each of the types will be broken down in natural language.

```typescript
const HEADER = Symbol.for('headers')
const STATUS = Symbol.for('status')

type HttpMetadata      = {[HEADER]: {[key: string]: string}} & {[STATUS]: number};
type UserResponse      = string | AsyncIterable<Buffer | string> | Buffer | Object;
type BoltzmannResponse = (AsyncIterable<Buffer | string> | Buffer | Object) & HttpMetadata;
type Handler           = (context: Context, ...args: any[]) => UserResponse | Promise<UserResponse>;
type Next              = (context: Context, ...args: any[]) => Promise<BoltzmannResponse>;
type Adaptor           = (next: Next) => Handler | Promise<Handler>;
type Middleware        = (options?: Object) => Adaptor;

function middleware (_options = {}) {
  return function adaptor (next: Next): Handler {
    return async function handler (context: Context, ...args): Promise<UserResponse> {
      return next(context, ...args)
    }
  }
}
```

Middleware has three parts: the outermost function receives _configuration
options_, which it is responsible for validating. It may throw an error if bad
options are provided, preventing the application from starting. Middleware is
generally called _once_ at application startup. Naming this function is useful:
the name of the middleware will be included in Honeycomb traces if that feature
is enabled, and it will be displayed by the development-mode debugging
middleware if a stall happens.

Middleware returns an `Adaptor` function. The `Adaptor` function receives a
`Next` function as an argument and returns a `Handler`. Adaptors, like the
outer middleware, are called _once_ at application startup. The `Adaptor` can
be asynchronous! If there are asynchronous setup steps, like connecting to a
database or reading a file from disk, they should be performed here. Again,
this function may throw an error if configuration is bad or necessary
resources are unavailable.

The application will not start accepting requests until the `Adaptor` returns a
`Handler`. The `Handler` is executed whenever your application receives an HTTP
request; it receives a [`Context`<EMAIL_ADDRESS>and returns a
[`UserResponse`](@/concepts/01-handlers.md). It may call the `Next` function
provided as an argument to the `Adaptor` function zero-to-many times. You can
think of calling `next()` as making a request to the inner part of your
application! `next()` will **never** throw, and the return value is guaranteed
to have a status code and headers associated with it. The body of the `Handler`
is where your middleware logic should be implemented.

---

## Attaching & Configuring Middleware

Middleware may be attached in one of two places, which is referred to as the
"scope" of the middleware. The widest scope is application-wide: if you need
logic to be performed on every request sent to your application, you can attach
it in `middleware.js` or `middleware/index.js` by exporting an `APP_MIDDLEWARE`
property that points at an array of your middleware:

```javascript
// middleware/index.js
const myMiddleware = require('./my-middleware')

module.exports = {
  APP_MIDDLEWARE: [
    myMiddleware
  ]
}
```

This will register the middleware application-wide. Application-scope attached
middleware will execute before Boltzmann routes the request; they will execute
even for requests that **match no corresponding route** in your application!

If, on the other hand, you need logic to be applied to **many** handlers, but not
**all**, you may wish to attach your middleware directly to handlers:

```javascript
// handlers.js

module.exports = {
  palindromesOnly,
  anyWords
}

anyWords.route = 'GET /any/:utterance'
function anyWords (context, { utterance }) {
  return 'yep that seems about correct'
}

const handleNonPalindromes = require('../middleware/non-palindromes')
palindromesOnly.route = 'GET /palindromes/:utterance'
palindromesOnly.middleware = [
  handleNonPalindromes // highly sophisticated middleware that 404s on non-palindromes
]
function palindromesOnly (context, { utterance }) {
  return 'ok ko'
}
```

In this example, only `palindromesOnly` is guarded by the
`handleNonPalindromes` middleware.

---

Both app-wide and handler-specific middleware scopes accept an `Array` of
`Middleware`. Middleware is executed in order, and responses from inner middleware
bubble back up the list in reverse order:

```javascript
// middleware.js
module.exports = {
  APP_MIDDLEWARE: [
    one,
    two,
    three
  ]
}
```

```javascript
// handlers.js
module.exports = { hello }

hello.route = 'GET /'
hello.middleware = [
  four,
  five
]
function hello (context) {
  return 'six'
}
```

In this example, a request to `GET /` will execute `one`, `two`, `three`,
`four`, `five`, and finally respond with six. The `'six'` response will be
received by `five`, then `four`, then `three`, and so on.

If a given middleware requires additional configuration, it can be provided
arguments by turning the entry into an array of `[Middleware, ...arguments]`,
which will be evaluated when the application starts up:

```javascript
// middleware.js
module.exports = {
  APP_MIDDLEWARE: [
    one,
    [two, {wow: 'an argument'}], // configure "two" with additional params
    three
  ]
}
```

```javascript
// handlers.js
module.exports = { hello }

hello.route = 'GET /'
hello.middleware = [
  [four, 'argument one', 'argument two'],
  five
]
function hello (context) {
  return 'six'
}

```

Insofar as is possible, middleware _should_ be designed such that attaching
it with no arguments is valid. If configuration is necessary, it should fail
noisily at startup!

## Next Steps

Now that you know the vocabulary for middleware, and how and when to attach it
to your application, it's time to write some middleware. [This
guide][ref-guide] will take you through writing your first middleware. You may
also be interested in reviewing the [built-in middleware that Boltzmann makes
available][ref-reference]. Happy hacking!

[ref-di]: https://en.wikipedia.org/wiki/Dependency_injection
[ref-gzip]: https://github.com/entropic-dev/boltzmann/blob/latest/examples/custom-middleware/middleware/gzip.js
[ref-reference]: @/reference/03-middleware.md
[in the "handling user input"]: @/concepts/04-accepting-input.md

repository: entropic-dev/boltzmann

branch_name: refs/heads/latest

gha_language: TypeScript

repo_name: entropic-dev/boltzmann


text:
[stack overflow](https://stackoverflow.com/questions/16820336/what-is-saas-paas-and-iaas-with-examples)
[aws - types of cloud computing](https://aws.amazon.com/types-of-cloud-computing/)

### IaaS, PaaS, SaaS

IaaS, PaaS and SaaS are cloud computing service models.

##### IaaS

Infrastructure as a Service, as the name suggests, provides you the computing infrastructure, physical or (quite often) virtual machines and other resources like virtual-machine disk image library, block and file-based storage, firewalls, load balancers, IP addresses, virtual local area networks etc.

Examples: Amazon EC2, Windows Azure, Rackspace, Google Compute Engine., AWS s3, compose

##### PaaS

Platform as a Service, as the name suggests, provides you computing platforms which typically includes operating system, programming language execution environment, database, web server etc.

Examples: AWS Elastic Beanstalk, Windows Azure, Heroku, Force.com, Google App Engine, Apache Stratos.

##### SaaS

Software as a Service model you are provided with access to application software often referred to as "on-demand software". You don't have to worry about the installation, setup and running of the application. Service provider will do that for you. You just have to pay and use it through some client.

Examples: Google Apps, Microsoft Office 365.

Few additional points regarding your question:

AWS (Amazon web services) is a complete suite which involves a whole bunch of useful web services. Most popular are EC2 and S3 and they belong to IaaS service model.
Although Hadoop is based on previous works by Google(GFS and MapReduce), it is not from Google. It is an Apache project. You can find more here. It is just a distributed computing platform and does not fall into any of these service models, IMHO.
Microsoft's Windows Azure is again an example of IaaS.

IaaS - AWS s3

#### IaC
Infrastructure as Code

Chef
Puppet
Ansible
SaltStack
CloudFormation
Terraform

```

repository: thomasmeadows/developer-job-references

repo_name: thomasmeadows/developer-job-references


text:
# Baby Connect Project
This repository contains one part of a multi-part project to enable the
automation of adding data to the [Baby Connect](https://www.baby-connect.com)
service.

The flow is:

- User interacts with Amazon Echo
- Alexa skill is triggered (__baby-connect-alexa-skill__)
- The Alexa skill sends a message to an AWS SQS message queue.
- A Raspberry Pi running a listener
([baby-connect-sqs-listener](https://github.com/platta/baby-connect-sqs-listener))
receives the message from the message queue.
- The listener uses a library
([baby-connect](https://github.com/platta/baby-connect)) to log into the Baby
Connect web site and add the data.

Since Baby Connect doesn't expose an API, the
([baby-connect](https://github.com/platta/baby-connect)) library uses browser
automation. This requires launching chromium as a child process which is not
supported in Lambda and is the reason we use a message queue with a standalone
listener application.

# baby-connect-alexa-skill

This repository contains the resources necessary to create an Alexa Skills Kit
skill to allow you to use your Echo to log data into Baby Connect.

## Setup

You'll need to create an account on
[Amazon Developer](https://developer.amazon.com) to begin creating your skill.

You can read through the
[Custom Skill Tutorial](https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/overviews/steps-to-build-a-custom-skill)
to get an understanding of the components involved. Some resources are required
besides the code for the Lambda function that will drive the skill. These
resources can be found in the `speechAssets` folder.

To prepare the Lambda function, install the dependencies in the `src` folder
using `npm`.

```bashp
cd src
npm install
```

Create a `config.json` file in the `src` folder using `config.default.json` as
a model.

Zip the files in the `src` folder (not the folder itself) and upload that as the
source of your Lambda function.

repository: Saiuz/baby-connect-alexa-skill

repo_name: Saiuz/baby-connect-alexa-skill


text:
# Castor - CMS for HSE students

---

## About

This project is based on @erikas boilerplate. Development of the project is for educational purpose to create an web-application that connects to remote API server written with ASP.NET 5.
To see code for API server visit castor-api.

Node api server is going to be excluded from the project.

## Installation

```bash
npm install
```

## Running Dev Server

```bash
npm run dev
```

The first time it may take a little while to generate the first `webpack-assets.json` and complain with a few dozen `[webpack-isomorphic-tools] (waiting for the first Webpack build to finish)` printouts, but be patient. Give it 30 seconds.

## Building and Running Production Server

```bash
npm run build
npm run start
```

## Demo
TBD

## Documentation
TBD

#### Unit Tests

The project uses [Mocha](https://mochajs.org/) to run your unit tests, it uses [Karma](http://karma-runner.github.io/0.13/index.html) as the test runner, it enables the feature that you are able to render your tests to the browser (e.g: Firefox, Chrome etc.), which means you are able to use the [Test Utilities](http://facebook.github.io/react/docs/test-utils.html) from Facebook api like `renderIntoDocument()`.

To run the tests in the project, just simply run `npm test` if you have `Chrome` installed, it will be automatically launched as a test service for you.

To keep watching your test suites that you are working on, just set `singleRun: false` in the `karma.conf.js` file. Please be sure set it to `true` if you are running `npm test` on a continuous integration server (travis-ci, etc).

## Roadmap

repository: codejunkienick/castor-frontend

repo_name: codejunkienick/castor-frontend


text:
# Changelog for unreleased

The following sections list the changes for unreleased.

## Summary

 * Chg #1: Initial release of basic version

## Details

 * Change #1: Initial release of basic version

   Just prepared an initial basic version to serve a hello world API that also provides a Phoenix
   extension to demonstrate the plugin architecture in combination with Phoenix and ownCloud
   Infinite Scale.

   https://github.com/owncloud/ocis-hello/issues/1

repository: butonic/ocis-hello

repo_name: butonic/ocis-hello


text:
# Commands

Commands are an essential part of Overcord. Commands allow you to create code
that executes in response to users typing certain commands to your bot.

::: tip

Commands must be executed by typing your bots command prefix, followed by the
command name. If you want more control over when code will execute, then
creating an event may be necessary.

:::

## Creating a Simple Command

Creating a command in Overcord is super simple. Start by creating a new file in
your commands directory, `Hi.ts`.

The following code will create a command that simply says 'hi' when the command
`!hi` or `!hello` is used:

```ts
import { Alias, Command, Client } from "@frasermcc/overcord";
import { Message } from "discord.js";

@Alias("hi", "hello")
export default class HiCommand extends Command {
    async execute(message: Message, client: Client) {
        return message.channel.send("Hi!");
    }
}
```

::: warning

Commands should always be the default export out of a file.

:::

- We use the `Alias` decorator to name a command. We can pass through any number
  of values, which must be unique amongst all other commands. Your command can be
  called by any of these names.
- We override the execute method to determine what should happen if the command
  is run successfully. The execute method exposes the message that invoked the
  command, as well as the client object.

## Commands with Arguments

Overcord can be used to require arguments to your commands. Arguments are
additional inputs beyond just typing the command name. In the following example,
we'll create a command that takes a number as an argument, and returns that
number minus 1.

```ts
import {
    Alias,
    Command,
    Argument,
    IntegerType,
    Client,
} from "@frasermcc/overcord";
import { Message } from "discord.js";

@Alias("subtractone")
export default class SubtractOneCommand extends Command {
    @Argument({ type: new IntegerType(), validate: (n) => !n.isNan() })
    someInteger!: number;

    async execute(message: Message, client: Client) {
        return message.channel.send(`Your number minus one is ${someInteger - 1}!`);
    }
}
```

When a user invokes this command with `!subtractone 15`, the value `15` will be
injected into the `someInteger` class field. You can then have access to this
value in any method inside the command.

In overcord, arguments are defined by using fields in a class. When the command
is executed, the provided arguments will be injected into these fields *in order*. So if you have:

```ts
    @Argument({ type: new IntegerType() })
    intOne!: number;
    @Argument({ type: new IntegerType() })
    intTwo!: number;
```

...then the first argument typed out would be injected into intOne, and the second
argument typed out would be injected into intTwo.

For more information about arguments in Overcord, check out the guide page on
Arguments.

repository: nzbasic/overcord

repo_name: nzbasic/overcord


text:
## Contract Design Patterns

There are 4 contracts in the project.

- The LeagueFactory contract's only job is to keep track of and deploy new Players contracts.

- The Players contract is an ERC721 based token contract that keeps track of which addresses owns which players; adding and dropping players happens here.

- The Players logic contract implements the functions inside the Players contract for the purposes of upgradability; this also consequently makes the Players contract much lighter.

- The League contract keeps track of organizing games, rosters, and standings among the teams. Note that this contract has no control over the players (non-funglible tokens) at all.

These decisions were made so that the the contracts are more flexible and upgradable.


text:
# Changelog
All notable changes to this project will be documented in this file.

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

## [4.0.0] - 2023-07-28
### Added
- Add Preview-Publish & Preview-Publish-Dispatcher orchestration logic #RS-161

## [3.0.1] - 2020-12-02
### Fixed
- Fixed failing connection when Author ELB is assigned with a self-signed certificate #56

## [3.0.0] - 2020-11-23

### Added
- Add configuration to control the verification of the SSL Certificate when executing API calls to AEM #51

### Changed
- Replaced ELB Client with ELBv2 client to support the new AEM OpenCloud architecture which uses an Application Load Balancer #47
- Changed `com.shinesolutions.aemorchestrator.config.ProxyConfig` to return empty string instead of `null` #49
- Change SSL Verification of the AEM SSL certificate to false #51
- Change default AEM connection configuration from HTTP to HTTPS #54

## [2.0.1] - unknown

### Added
- Added new COMPONENT_INIT_STATUS to instance tags

### Changed
- Change default orchestrator and replicator credentials to overwrite-me/overwrite-me
- Changed process of determining the healthy publish instance to check component init state instead of just AEM health

## [2.0.0] - unknown

### Added
- Add JCR content CQ distribute property to post agent request model

### Changed
- Upgrade swaggeraem4j to 0.10.0 with AEM 6.4 support

## [1.0.3] - unknown

### Changed
- Change alarm.content.health.check.terminate.instance.enable default to false
- By default, Orchestrator does not terminate instance when content health check fails

## [1.0.2] - unknown

### Changed
- Fix aws.cloudformation.stackName.publishDispatcher to be really the stack name, it used to have stack ARN

## [1.0.1] - 2018-01-18

### Added
- Add debug logs showing raw message on each event handler #34

### Changed
- Fix replication agent pausing not adding activated content to the queue #31
- Fix unrecognised InvokingAlarms field error when ASG scale up policy is triggered #30
- Modify resource readiness checker to use exponential backoff retry policy #29

## [1.0.0] - 2017-06-02

### Changed
- increase the default the wait for healthy author elb time to 12.5 minutes.
- ignore auto scaling launch event fired from moving ec2 instance out of standby
- use the oldest publish instance with snapshot id tag to get a snapshot from for new publish instance

## [0.9.3] - unknown

### Added
- Added a standardized name tag to the publish snapshot #16
- Added relaxed SSL support to AEM replication agent creation #24

### Changed
- By default, now logs to root application directory (orchestrator.log)
- Performs a health check on the Publish instance before doing a Snapshot #15
- Fixed bug causing continual snapshotting when unable to find a publish pair candidate #12
- Creates a content health check alarm on the publish instance #19
- Fix cross-snapshotting publish instances #13
- Changed loading of AWS credentials to use 'Instance Profile' only #17
- Changed the HTTP Method from POST to GET for reverse replication #22
- Changed '/libs/cq' to just 'cq' for sling:resourceType when creating a replication agent #23
- Now reads the SNS topic ARN from Cloud Formation based on the logical id #21
- Scale down handlers now cater for inexisting replication/flush agent #18
- Creation of reverse replication agents now includes 'userId' attribute
- Prioritises Publish and Publish-Dispatcher instances from same AZ #3

## [0.9.2] - unknown

### Added
- Added configurable snapshot tags #2
- Added support for reverse replication queues

### Changed
- Device name (used for snapshots) is now configurable #10
- Reading a test notification message off the SQS queue no longer causes the logs to show an error #7
- Fixed a bug where the scale down actions were not triggering correctly, causing replication agents to never be removed
- Fixed NoSuchElementException error when scaling publish up bug #4
- Fixed unable to delete flush and replication agents #11

## [0.9.1] - unknown

### Added
- Initial version

repository: shinesolutions/aem-orchestrator

gha_language: Java

repo_name: shinesolutions/aem-orchestrator


text:
# Example of Rails, Sidekiq and Puma metrics exported to Prometheus + Grafana

This example illustrates how to use [yabeda] gem suite with rails application to draw graphs for app metrics.

## Prerequisites

Recent versions of Docker and Docker Compose installed.

## Usage

- Execute `docker-compose up` to start.
- Go to rails application at http://localhost:5000
- Hit the button and refresh page few times
- Go to Grafana Web UI at [localhost](http://localhost:3000/d/000000001/yabeda-metrics-for-rails-sidekiq-and-puma?refresh=5s) (user: `admin`/`admin`)
- Look for graphs
- After starting up docker-compose will run `rails-stressor` service to simulate huge load for the rails app. By default will do the request for 2 minutes.
Settings could be changed in `docker-compose.yml` config (command parameter of the `rails_stressor` service).

You also could run rails stressor again by executing `docker-compose up rails_stressor` command.

## Notes

- Sample [Rails] application is equipped with [yabeda-rails], [yabeda-sidekiq], [yabeda-puma-plugin], and [yabeda-prometheus] gems and properly configured.
- Raw rails metrics are exposed at http://localhost:5000/metrics
- Raw sidekiq metrics are exposed at http://localhost:5100/metrics
- Raw puma metrics are exposed at http://localhost:5100/metrics
- The [Prometheus] Web UI runs at http://localhost:9090
- The [Grafana] Web UI runs at http://localhost:3000 , user: `admin`/`admin`.
- The [Sidekiq] Web UI is available at http://localhost:5000/sidekiq

## Possible errors and their solutions

### Permission denied error / My grafana container is not running (Stopping after boot)

If your grafana's container is not running correctly after you run `docker-compose up` you're probably getting this error, if you check at `docker ps -a` you'll see your grana container with the status `Exited`, picks the id of this container and run `docker logs YOUR_GRAFANA_CONTAINER_ID` and check if the errors is equal to the following:

```
GF_PATHS_DATA='/var/lib/grafana' is not writable.
You may have issues with file permissions, more information here: http://docs.grafana.org/installation/docker/#migration-from-a-previou
s-version-of-the-docker-container-to-5-1-or-later
mkdir: cannot create directory '/var/lib/grafana/plugins': Permission denied
```

#### Solution

Replace at your `docker-compose.yml` line 38 by your user's `id` that you will get on the following command:

```sh
id -u
```

## Acknowledgement

The configurations are based off the following articles and repositories:
 - https://finestructure.co/blog/2016/5/16/monitoring-with-prometheus-grafana-docker-part-1
 - https://github.com/NikolajLeischner/local-prometheus-grafana
 - https://www.digitalocean.com/community/tutorials/how-to-add-a-prometheus-dashboard-to-grafana

## License

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

[yabeda]: https://github.com/yabeda-rb/yabeda
[yabeda-rails]: https://github.com/yabeda-rb/yabeda-rails
[yabeda-sidekiq]: https://github.com/yabeda-rb/yabeda-sidekiq
[yabeda-puma-plugin]: https://github.com/yabeda-rb/yabeda-puma-plugin
[yabeda-prometheus]: https://github.com/yabeda-rb/yabeda-prometheus
[Rails]: https://rubyonrails.org "Ruby on Rails MVC web-application framework optimized for programmer happiness"
[Sidekiq]: https://github.com/mperham/sidekiq/ "Simple, efficient background processing for Ruby"
[Prometheus]: https://prometheus.io/ "Open-source monitoring solution"
[Grafana]: https://grafana.com/

repository: yabeda-rb/example-prometheus

gha_language: Ruby

repo_name: yabeda-rb/example-prometheus


text:
# Introduction

Lasku is a Web-based invoicing system for freelancers and small businesses,
inspired by FusionInvoice.
The goal of Lasku is to provide a professional and powerful invoicing system
yet simple, easy to install and easy to use, for daily invoicing use by freelancers and small businesses.
This documentation will guide you to install and use Lasku Invoicing System.

You may select a topic on the sidebar or read a common topic below.

### [Installing Lasku](install/install)

A brief guide on how to install Lasku on a web server as well as shared
hosting.

### [Getting Started](getting-started)

Quick explanation on how to use Lasku.

### [Frequently Asked Questions](faq)

As the title says, frequently asked questions.

repository: fujaru/lasku

repo_name: fujaru/lasku


text:
# Notestack.me

### About
Notestack.me is a web-based simplenote client for the modern browser. It takes advantage of browser localStorage, a new HTML5 feature, to store your notes locally and make them available even when your internet connection is down.

### Contribute
If you want to contribute, go ahead and fork this repository, make some changes, then submit a pull request for me to review. I'm happy to discuss any ideas you have for improvements.

### Issues
Click on over to the [issue tracker](http://github.com/brittohalloran/notestack/issues) and log an issue.

### Contact
Contact Britt O'Halloran ([britt.j.ohalloran@gmail.com](mailto:britt.j.ohalloran@gmail.com)) if you have any questions

repository: srea/notestack

repo_name: srea/notestack


text:
---
draft: false
date: 2023-02-15
categories:
  - Release
title: "Textual 0.11.0 adds a beautiful Markdown widget"
authors:
  - willmcgugan
---

# Textual 0.11.0 adds a beautiful Markdown widget

We released Textual 0.10.0 25 days ago, which is a little longer than our usual release cycle. What have we been up to?

<!-- more -->

The headline feature of this release is the enhanced Markdown support. Here's a screenshot of an example:

<div>
--8<-- "docs/blog/images/markdown-viewer.svg"
</div>

!!! tip

    You can generate these SVG screenshots for your app with `textual run my_app.py --screenshot 5` which will export a screenshot after 5 seconds.

There are actually 2 new widgets: [Markdown](./../../widgets/markdown.md) for a simple Markdown document, and [MarkdownViewer](./../../widgets/markdown_viewer.md) which adds browser-like navigation and a table of contents.

Textual has had support for Markdown since day one by embedding a Rich [Markdown](https://rich.readthedocs.io/en/latest/markdown.html) object -- which still gives decent results! This new widget adds dynamic controls such as scrollable code fences and tables, in addition to working links.

In future releases we plan on adding more Markdown extensions, and the ability to easily embed custom widgets within the document. I'm sure there are plenty of interesting applications that could be powered by dynamically generated Markdown documents.

## DataTable improvements

There has been a lot of work on the [DataTable](../../widgets/data_table.md) API. We've added the ability to sort the data, which required that we introduce the concept of row and column keys. You can now reference rows / columns / cells by their coordinate or by row / column key.

Additionally there are new [update_cell][textual.widgets.DataTable.update_cell] and [update_cell_at][textual.widgets.DataTable.update_cell_at] methods to update cells after the data has been populated. Future releases will have more methods to manipulate table data, which will make it a very general purpose (and powerful) widget.

## Tree control

The [Tree](../../widgets/tree.md) widget has grown a few methods to programmatically expand, collapse and toggle tree nodes.

## Breaking changes

There are a few breaking changes in this release. These are mostly naming and import related, which should be easy to fix if you are affected. Here's a few notable examples:

- `Checkbox` has been renamed to `Switch`. This is because we plan to introduce complimentary `Checkbox` and `RadioButton` widgets in a future release, but we loved the look of *Switches* too much to drop them.
- We've dropped the `emit` and `emit_no_wait` methods. These methods posted message to the parent widget, but we found that made it problematic to subclass widgets. In almost all situations you want to replace these with `self.post_message` (or `self.post_message_no_wait`).

Be sure to check the [CHANGELOG](https://github.com/Textualize/textual/blob/main/CHANGELOG.md) for the full details on potential breaking changes.

## Join us!

We're having fun on our [Discord server](https://discord.gg/Enf6Z3qhVr). Join us there to talk to Textualize developers and share ideas.

repository: Textualize/textual

gha_language: Python

repo_name: Textualize/textual


text:
# Used commands
_by page in the courseware_

## Before (with `.my.cnf` setted)
In the MySQL Server terminal:
``` sql
CREATE DATABASE a19locadora;
CREATE DATABASE a19sistEdu;
exit;
```
In the Bash terminal:
``` bash
mysqldump a18locadora | mysql a19locadora;
mysqldump --routines a17sistEdu | mysql a19sistEdu;
mysql
```
## p04 onwards
- Download the [JDBC driver for MySQL](https://dev.mysql.com/downloads/connector/j/) (I prefer "Platform Independent" option).
- Follow the programming steps on the courseware text.
- Use some Java IDE (like Eclipse, e.g.). I used "File > New > Java Project" option.
- On the creation wizard, add the downloaded MySQL driver.

repository: igorasantos/Tec-Web-exercises

repo_name: igorasantos/Tec-Web-exercises


text:
# pfred-docker

# Description
This is a repository for the Dockerfile and file dependencies for the RESTful-PFRED service that is compiled as a `.war` file (see [pfred-rest-service](https://github.com/pfred/pfred-rest-service)).

# Creating the pfredservice docker container
## Cloning this repository (Windows)
If you are cloning this repository and wnat to create the service in a Windows machine, then set `git` to not change the scripts `EOL` Unix setting. Do this via the following git command in CLI:

`git config --global core.autocrlf false`

Then the environment on WIndows should be ready to deploy.

## Image builder
To use this Dockerfile layer, run the following docker command:

`docker build -t pfredimg .`

Note that this process will setup the pfredservice environment and install all needed
dependencies. Process might take up to 10 mins in a regular modern laptop.

## Running the service container

Once the pfredimg image has been created, docker should now show the status and running uptime:

`docker images`

Then, the container can be loaded by the following command:

`docker-compose up -d`

If run for the first time, this will create a docker volume named `dockerfiles-sl_pfred-vol` and a docker container
named `pfredservice`. Note that the `-d` flag will detach the shell from the running container, the RESTful service will not be ready to use until the command `docker-compose logs` shows a `Tomcat started` message.

Once the service is ready, you should be able to access the REST API at https://os.biogen.com/PFREDRestService/api. Keep in mind that the `entrypoint` will download the scripts and data generated from `bowtie`, therefore it might take up to 10 mins while the container downloads everything it needs before the pfredservice is ready.

The `entrypoint` will also create a docker volume named `pfred-docker_pfred-vol` so that if the pfredservice docker container is killed, it can be reloaded via the command:

`docker-compose up -d pfred-service`

And the service container should be immediately ready for use since all the data has been stored into `pfred-docker_pfred-vol`.

## Unloading the service container and cleaning up

Once the service has been used and it is not longer needed, execute:

`docker-compose down`

This will remove containers, networks, volumes and images created by `docker-compose up`.

If the pfredimg is not longer needed, it can be removed via the command:

`docker rmi pfredimg`

Likewise for the docker volume. If it is not longer needed, run the command:

`docker volume rm pfred-docker_pfred-vol`

Docker provides a single command that will clean up any resources — images, containers, volumes, and networks
that are dangling (not associated with a container), and to additionally remove any stopped containers and
all unused images (not just dangling images), add the -a flag to the command:

`docker system prune -a`

Then you should see no images or volumes,

`docker images -a`

`docker volume ls`

repository: yangluom/pfred-docker

repo_name: yangluom/pfred-docker


text:
# Podospora horridula (Sacc.) Dennis & S.M. Francis, 1984 SPECIES

#### Status
ACCEPTED

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

#### Published in
in Francis & Sparrow, Trans. Br. mycol. Soc. 82(2): 380 (1984)

#### Original name
Rosellinia horridula Sacc., 1884

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
# Changelog

## [2.0.0](https://www.github.com/gulpjs/undertaker-registry/compare/v1.0.1...v2.0.0) (2021-12-29)

### ⚠ BREAKING CHANGES

* Normalize repository, dropping node <10.13 support (#10)

### Miscellaneous Chores

* Normalize repository, dropping node <10.13 support ([#10](https://www.github.com/gulpjs/undertaker-registry/issues/10)) ([7d54ad8](https://www.github.com/gulpjs/undertaker-registry/commit/7d54ad84f6ed37fb1ab0b5d8eaf6934cb1626894))

repository: gulpjs/undertaker-registry

repo_name: gulpjs/undertaker-registry


text:
Installing Oshino
==================
Just let the PIP do the job for you

`pip install oshino`

However, you might want to setup and enter into [virtual environment](https://docs.python.org/3/tutorial/venv.html) before proceeding with installiation

Requirements
------------
- Python 3.5+ version - for async functionallity
- Have Riemann node running - for receiving events

repository: CodersOfTheNight/oshino

repo_name: CodersOfTheNight/oshino


text:
# Custom Properties Support

CSS Custom Properties, aka CSS variables, are only supported by current browsers.

| Browser | Supported release | Release date | Engine |
|---|---|---|---|
| Chrome	| 49 | March 2, 2016 | Blink |
| Safari	| 9.1 | March 20, 2016 | Webkit |
| Firefox | 31 | July 21, 2014 | Gecko |
| Edge		| 16 | October 16, 2017 | EdgeHTML |
| Opera 	| 36 | March 6, 2016 | Blink |
| Internet Explorer | no support | no support | Trident |

As a result, when CSS Custom Properties are used, the use of fallback CSS is necessary to support legacy Internet Explorer users.

## How CSS Custom Properties Work

With supporting browsers, the following code example would render the appropriate color in the view.

```css
:root {
  --base-color: #222000;
}

.selector {
  color: var(--base-color);
}
```

In cases with Web Components that use the shadowDOM with encapsulated CSS support, custom properties can be written to the scope of the component. In this example, the `:host` selector would overwrite the `:host` selector and render the color red versus black.

```css
:host {
  --base-color: #ff000;
}

.selector {
  color: var(--base-color);
}
```

### Legacy browser support

Browsers work on the principal of progressive enhancement. This means that you can send code to the browser that it does not understand and it will simply ignore it. When using CSS custom properties, this means that the value will never be rendered to the view and your UI will appear broken.

The solution for this is to provide fall back properties like so:

```css
.selector {
  color: #ff000;
  color: var(--base-color);
}
```

With this code, any browser will see `color: #ff000;`. Those that understand `color: var(--base-color);` this property will override the previous. For those that do not understand this property, it will simply ignore.

### Fallback properties at scale

Producing fallback properties at scale require additional CSS processing. This and other projects use the PostCSS plugin of postcss-custom-properties. There are many framework dependent uses from Gulp to Webpack. The following is a Node version.

```javascript
/* ./scripts/postcss.js */

const postcss = require('postcss');
const postcssCustomProperties = require('postcss-custom-properties');
const fs = require('fs');

const startingCSS = './raw.css';
const finishCSS = './dist.css';

fs.readFile(startingCSS, (err, css) => {
  postcss([
    postcssCustomProperties ({ preserve: true }),
  ])
    .process(css, { from: startingCSS, to: finishCSS })
    .then(result => {
      fs.writeFile(finishCSS, result.css, () => true)
    })
})
```

Using this script, the following CSS ...

```css
:root {
  --base-color: #222000;
}

.selector {
  color: var(--base-color);
}
```

will output the following:

```css
:root {
    --base-color: #222000;
}

.selector {
  color: #222000;
  color: var(--base-color);
}
```

##

Alaska Airlines Orion Design System<br>
Copyright 2019 Alaska Airlines, Inc. or its affiliates. All Rights Reserved.

repository: znewton/ODS-WC-Generator

repo_name: znewton/ODS-WC-Generator


text:
restruct is an open source project that anyone can contribute to. This file contains a list of all contributors up to this point. This list is obtained by running `git shortlog -s` and is listed in alphabetical order. If this file falls out of date and is missing a name, or an entry should be changed, please [file an issue](https://github.com/go-restruct/restruct/issues/new).

  * [Dave Cheney](https://github.com/davecheney)
  * [John Chadwick](https://github.com/jchv)
  * [jlojosnegros](https://github.com/jlojosnegros)

license: ISC

repository: go-restruct/restruct

gha_language: Go

gha_license_id: ISC

repo_name: go-restruct/restruct


text:
# Db2

Author: David Vande Pol (IBM)

To build the db2 container that is required for Customer Order Service application simply RUN

`docker build . -t storefront-db2`

This loads the script populateDB.sh which will populate the database after creation.

To run the database run the command

`docker run --name storefront-db2 --privileged=true -e LICENSE=accept  -e DB2INST1_PASSWORD=db2inst1 -e DBNAME=orderdb -p 50000:50000 storefront-db2`

If you want to connect to the database from another container you have to run on the same network.

`docker create network store-front-network`

`docker run --name storefront-db2 --network store-front-network --privileged=true -e LICENSE=accept  -e DB2INST1_PASSWORD=db2inst1 -e DBNAME=orderdb -p 50000:50000 storefront-db2`

Then in the tWAS container we would include `--network store-front-network` reference the database using hostname `torefront-db2`.


text:
---
layout: page
title: Welcome!
tagline:
---
{% include JB/setup %}

My name is Charlie Hubbard and you've made your way to my blog.  Congrats!

## About the Blog
This blog was created highlight my exploration of machine learning, recommendation systems and GPU computing as a graduate reserach assistant at Iowa State University.  While the blog is in its infancy I will mostly be posting about past projects and completed work.  Once I have caught up to my current research I will begin posting more broadly about data science as I work to build my own skill set.

## About the Author
I am a second years masters student at Iowa State University in the Department of Electrical and Computer Engineering and a graduate research assistant under Dr. Chinmay Hegde.  With Dr. Hegde I study the application of GPU computing to machine learning and recommendation systems.  You can find links to my papers, presentations as well as more about me [here](/about)!


text:
# probe-py
a simple API client for probe apis in python

## how to install

you can install probe-py from pypi

```bash
$ pip install probe-py
```

## how to run

first set an environment variable for api key

```bash
$ export api_key='your api key'
```

### to search company with the company name starting substring
```python

from probe import SearchApi

client = SearchApi()

client.companies_get('api version', filters='{"nameStartsWith": "company-name"}')
```

### to search an authorized signatory with pan/din
```python

from probe import SearchApi

client = SearchApi()

client.authorized_signatories_get(filters='{"pan": "PAN Number of Signatory"}')
```

### to get company details using cin

```python

from probe import CompanyApi

client = CompanyApi()

client.companies_cin_get('api version', 'Company-cin')
```

### list companies authorized signatories

```python

from probe import CompanyApi

client = CompanyApi()

client.companies_cin_authorized_signatories_get('api version', 'Company-cin')
```

### to get the company charges

```python
from probe import CompanyApi

client = CompanyApi()

client.companies_cin_charges_get('api version', 'Company-cin')
```

repository: loanzen/probe-py

repo_name: loanzen/probe-py