text:
# Node Sandbox

A nifty javascript sandbox for node.js.

## Some features

- Can be used to execute untrusted code.
- Support for timeouts (e.g. prevent infinite loops)
- Support for memory errors (and memory errors)
- Handles errors gracefully
- Restricted code (cannot access node.js methods)
- Supports `console.log` and `print` utility methods
- Supports interprocess messaging with the sandboxed code

## Example

Be sure to check out [example/example.js](https://github.com/gf3/sandbox/blob/master/example/example.js)

```javascript
var s = new Sandbox();
s.run('1 + 1 + " apples"', function(output) {
  // output.result == "2 apples"
});
```

## Documentation

### `Sandbox`#`run`(`code`, `hollaback`)

* `code` {`String`} — string of Javascript to be executed.
* `hollaback` {`Function`} — called after execution with a single argument, `output`.
    - `output` is an object with two properties: `result` and `console`. The `result`
      property is an inspected string of the return value of the code. The `console`
      property is an array of all console output.

For example, given the following code:

```javascript
function add(a, b){
  console.log(a);
  console.log(b);
  return a + b;
}

add(20, 22);
```

The resulting output object is:

```javascript
{
  result: "42",
  console: ["20", "22"]
}
```

### `Sandbox`#`postMessage`(`message`)

* `message` {`String`} - message to send to the sandboxed code

For example, the following code will send a message from outside of the sandbox in
and then the sandboxed code will respond with its own message. Note that the sandboxed
code handles incoming messages by defining a global `onmessage` function and can
send messages to the outside using the `postMessage` function.

Sandboxed code:
```javascript
onmessage = function(message){
  if (message === 'hello from outside') {
    postMessage('hello from inside');
  }
};
```

Sandbox:
```
var sandbox = new Sandbox();
sandbox.run(sandboxed_code);
sandbox.on('message', function(message){
  // Handle message sent from the inside
  // In this example message will be 'hello from inside'
});
sandbox.postMessage('hello from outside');
```

The process will ONLY be considered finished if `onmessage` is NOT a function.
If `onmessage` is defined the sandbox will assume that it is waiting for an
incoming message.

## Installation & Running

Let's get it! The easiest way is through npm:

    npm install sandbox

Or if you'd like to play with the code, see the examples, run the tests,
what-the-fuck-ever...

    git clone git://github.com/gf3/sandbox.git

And run some examples:

    node example/example.js

## Tests

To run the tests simply run the test file with node.

    npm test

## License

Sandbox is [UNLICENSED](http://unlicense.org/).

## Contributors

- [Gianni Chiappetta](http://github.com/gf3) – [gf3.ca](http://gf3.ca)
- [Bradley Meck](https://github.com/bmeck)
- [Dominic Tarr](http://github.com/dominictarr) – [cyber-hobo.blogspot.com](http://cyber-hobo.blogspot.com/)
- [Eli Mallon](https://github.com/iameli) – [iame.li](http://iame.li/)
- [Evan Schwartz](https://github.com/emschwartz)

license: Unlicense,MIT

repository: GothamSprings/codeWitch

detected_licenses: Unlicense MIT

repo_name: GothamSprings/codeWitch


text:
## NEAT Prescriptor

This example implements the prescription API using NEAT.
This example will not achieve high performance out-of-the-box.

The goal of this example is to provide an example of how the various
scaffolding can fit together to produce a valid prescriptor.

In particular, the prescriptor uses the input historical IPs file,
the input weights file, along with historical case data to make prescriptions.

This example is unoptimized.
For example, it uses default NEAT parameters,
uses a naiive fitness function,
and provides no method for selecting a tradeoff of evolved solutions.

It also uses a computationally inefficient method of iteratively calling the predictor
that scales quadratically with the number of calls.

### Setup

These assume the `covid-xprize` repo is located at `<workspace>/covid-xprize`.

If you have not already done so, install requirements, which include neat-python:
```
cd <workspace>/covid-xprize
pip install -r requirements.txt
```

Ensure that `covid-xprize` is in your PYTHONPATH:
```
export PYTHONPATH=$PYTHONPATH:<workspace>/covid-xprize/
```

### Training Prescriptors

The script `train_prescriptors.py` gives an example of how to train prescriptors.
Here's how it's used:
```
cd <workspace>/covid-xprize/covid_xprize/examples/prescriptors/neat/
python train_prescriptors.py
```
Periodically, this script saves the current population to `neat-checkpoint-*`.
These saved networks can then be used in prescriptor submissions.

There are MANY ways to improve `train_prescriptors.py`.
See the comments in the file for some example directions for improvement.

The script configures neat-python using the file `config-prescriptor`.
This file contains many options for the underlying algorithm.

### Prescribing with trained Prescriptors

The script `prescribe.py` implements the API required for prescriptor submissions.

As is, it simply loads one of the checkpoints from training,
and makes prescriptions with each network in that checkpoint.

Say we would like to prescribe using the checkpoint `neat-checkpoint-4`.
Then, open `prescribe.py` and change the line defining `PRESCRIPTORS_FILE` to
```
PRESCRIPTORS_FILE = 'neat-checkpoint-4'
```

Then, prescriptions can be generated by following the API.
For example, say we would like to generate predictions from August 1st to 5th,
and store the results in `test_prescriptions.csv`:
```
cd <workspace>/covid-xprize/covid_xprize/examples/prescriptors/neat/
python prescribe.py --start_date 2020-08-01 --end_date 2020-08-05 -ip ../../../validation/data/2020-09-30_historical_ip.csv -c ../../../validation/data/uniform_random_costs.csv -o test_prescriptions.csv
```

In general, it will be more useful to assemble a set of prescriptors for submission
in a more discerning way, and store and load them in a different way as well.

See the constants defined at the top of `prescribe.py` for other parameters that can be adjusted.

### Evaluating prescription performance

Once prescriptions are generated, different prescriptions for the same sets of geos and days
can be compared using the notebook `<workspace>/covid-xprize/prescriptor_robojudge.ipynb`:
```
cd <workspace>/covid-xprize/
jupyter notebook prescriptor_robojudge.ipynb
```

branch_name: refs/heads/main

extension: md

license_type: permissive


text:
# Coveo extension manager
Manages and helps test pipeline extensions. With this extension, you can quickly add an extension from an existing gallery that gets updated then test it right after with any document avaible in the organization. This improves how quickly one can test extensions and find mistakes.

## Install

If you are on Coveo domain, you can install from the [Chrome Web Store](https://chrome.google.com/webstore/detail/tester-for-indexing-pipel/gbaapjhekfgfnjkijijdfkllbfhobieb?hl=en-US).

## Description
This extension has 2 parts to it:
1. The extensions gallery
2. The extension tester

### The gallery
The extension gallery can be found when one clicks on the "Add Extension" button in the top right of the extensions page.
This is what is looks like:
![extension gallery button](https://user-images.githubusercontent.com/17149559/27692683-569b0ad6-5cb5-11e7-996f-1d4f8e12c08e.png)
When clicked on, a Coveo seach pops up with a list of available extensions. The extensions are added by the python script portion of the repo.
![extension gallery search](../screenshots/extensiongallery.png)

#### Additional notes
You can setup your own extension gallery, simply follow the instructions in the python section of this repo, then
change where where the content is being taken. Head to chrome://extensions/ and click on the options dialog.

### The tester
'Test' buttons can be found beside every extension
![test buttons](https://user-images.githubusercontent.com/17149559/27692869-cd622802-5cb5-11e7-8c69-f93b6b88c5f1.png)
Clicking on a 'Test' button will bring up the test interface
![test interace](../screenshots/selectdocument.png)
Simply clicking on the document you want to test will start the test and the results will appear

## How to build
1. Download/clone git repo
2. Turn on developer mode in chrome
3. Load unpacked extension
4. Find the `chrome_extension` folder in the repo under the `misc` folder

## How to run
Head to the Coveo Cloud Platform extension's tab

## Dependencies
Google Chrome or Chromium

## Demo
Demo of adding a new extesion then testing it immediately with an existing document
![demo gif](https://user-images.githubusercontent.com/17149559/27694135-46eed5b4-5cb9-11e7-9ab3-dac634291270.gif)

## Notes
The tester is only capable of getting indexed metadata, Body Text, Body HTML and Thumbnail.
Some metadata only exists when a real extension is being ran, so results may vary.
So in some cases, it's better to test with re-building a source.

It is currently not possible to test with a datastream in prod. The next rollout (August 5th, 2017) will allow this feature to work.

This was tested on Chromium 58.0 running Ubuntu 16.04

No additional support will be provided by the Coveo-Labs team

license: MIT

repository: narbehx/pipeline-extension-manager

branch_name: refs/heads/master

repo_name: narbehx/pipeline-extension-manager


text:
cache-resolver
==============

Describe a graph of dependencies, notify about a change in a dependency and notify the other dependencies that rely on it.

Setup
=====
```

// define an entity to have a cacheable property
var Cachie = require('cachie');
Cachie.entity('Invoice',{
  'total': {
    timeout: inf,
    deps: [
      {
        type: 'event',
        entity: 'InvoiceLineItem',
        event: 'create'
      }
    ]
  }
});

// set the property
cachie.set({
  entity: 'Invoice',
  property: 'total',
  value: 0,
  timeout: inf
});

// get the property
var total = cache.get({entity: 'Invoice', property: 'total'});

// invalidate it
cachie.broadcast({
  entity: 'InvoiceLineItem'
  event: 'create'
});

// add a property to an entity
cachie.entity('Invoice').addProperty('number_of_items',{
  timeout: inf,
  deps: [
    {
      type: 'event',
      entity: 'InvoiceLineItem',
      event: 'create'
    }
  ]
});
}
```

Expectation
===========
- Ticket record is created, Event.total_sales is invalidated
```
cachie.watch('Model.created','invalidate:Event.total_sales'
- Ticket field refunded is changed, Event.total sales is invalided
- Field on a model changes, broadcasts event about changed field
- Field on a model changes, broadcasts event about model updated
- Model is created, broadcasts event about new Model created
- Register cache key by Model, name and identifiers
-

repository: interlock/cache-resolver

repo_name: interlock/cache-resolver


text:
play_pixi
=========
A Dart port of pixi.js

* Full features were implemented.
* Full examples that were only minimally modified from original examples.
* Tested in CocoonJS.

The final goal of this package is to build Phaser game engine naming [play_phaser][1] in Dart lang.

Change log
==========
0.9.4+
 * upgrade to PIXI v1.6.1

0.9.4
 * upgrade to PIXI v1.6.0
 * strip snake example
 * complex graphics example

0.9.3
 * Fix touch event in cocoonJS
 * Fix type error
 * Fix mobile view size.

0.9.2
 * Fix example 11 (RenderingTexture) and example 15 (Filter) example in chrome.
 * Add Spine implementation and examples

[1]: https://github.com/playif/play_phaser


text:
---
title: Data Categories
layout: repo-content
---

This is a listing of all dataset categories currently being maintained on tera-PROMISE. Check out the brief descriptions of each category to find what you're looking for.

**Note:** Category descriptions are under construction as of May 11th.

{% for category in site.datacategories %}

{{category.title}}

  {{category.description}}

{% endfor %}


text:
# IT Architectural 20191008
Notes
- Send Barry SSO chat SSO script
- Talk w/ team about WT scaling.
-

# Drift / AC Integration 20191009
Notes
- Webhook when email is captured -> Save to AC automation
-

# IT Architectural 20191015
Actions
- Add BillR/BillS to Google Cloud
- Extra meta data for Chatroom
- Ask ATI about API.

# Staging Depot 20191015
Notes
-
Actions
- HP: Remove Living Room Bundles
- About: Remove

# Marketing Ops 20191016
Notes
- Custom variables on AC from CRM.
  - Ask Steph for custom variables.
  - This is addition to adding to AC tags.
  - Variable: Warrior Starter, Warrior Pro, Inner Circle
- Markedo
-

# Ross 20191016
Actions
- Net Sales First
- Sales Graph shows net net
- Special Rports -> Net Net

#
Ask Google AMP about bouncerate

# Speed Team 20191029
Notes
- Test env for privy
- Send Rakuten to Sean
- Doc on how to update Staging
-

# SD Ops 20191029
Notes
- Functional Specifications
- API Documentation
- For EZR
  - Need widgets to use BY NAME.
  - Availability Calendar For Items Grouped By Name NOT enabled for name.
-

# Marketing Ops 20191030
Notes
- Attribution modeling.
- 3 webinars for November.
-

# IT/Support Ops 20191104
Notes
- Product triggering
- CS Tab:
  - Not all functionality for everyone
  -
- Steph
  - Drift + AC
  - ? WebinarJam
  - ? Privy: Need an env
-

# Bill 1:1 20191104
Notes
- API Gateway Odin w/ Barry
- Documentation WP ATI plugin
- Ping Sean on WT PHP7

# IT Meeting Ops 20191107
Tasks
- Let Sean know about WTN K8s
- TweetID
- Privy ID
- Carina w/ new tab.
- GSheet Arsh
- CRM report on logins and required password changes.
- CRM auth w/ WP plugin and send to Barry
-

# IT Architectural 20191112
Tasks
- Develop test MCRYPT SSO page.
- Endpoint for each SOAP
  - SOAP definition file.

# Marketing Ops 20191113
Tasks
- Done: Coupon codes.
- Test Warrior Pro Payment Plans December
- Alternative to WebinarJam
  - Markedo
  - Webinar Ninja

# IT/Support Ops 20191119
Tasks
- CRM enable/disable Sterling goes to an error page?
- Test SSO page that includes new chatroom button. Already made one?
- Create Chatroom beta links like https://www.warriortrading.com/chat-room-access-20191021/

# Support Ops 20191202
Tasks
- Support / Marketing CRM on Monday
- CRM -> ActiveCampaign
- Drift - AC
- Drift - WebinarJam
- New Chat Beta Link
- CS tab needs refunds
- Order tab on a customer has the ability to delete the order?
- Add /clear on before chatroom login (a button or something)
-

# Bill 20191202
Tasks
- Notify Barry about SSO
- Done: FU w/ Joseph about AMP paper-trading
- Memcached - Build one
-

# Speed Team 20191203
Tasks
- Penny Stock
- Memcached
- WBS of Gatsby of 1st Phase
- Roll out Gatsby Homepage for pagespeed benchmarking.
-

# IT Architecture 20191203
Tasks
- Decrypt cookie and get products list.

# IT Ops 20191205
Tasks
- Done: Authorize.net to Bill R
- Done: Delete unused RDS.
- Pause/Unpause w/ CRM products ???
- Report on password CRM age.
-

# East Bay WP 20191208
Notes
-

# Bill
Notes
- Ask to be copied at
  - itadmin@
  - bill@
  - accountspayable@
  - Needs to be a PDF, breakdown of costs.
- Hold off on memcache
-

# Bill 20191216
Tasks
- Done: Report on how to pull active subscribers via CRM.
- Pagespeed scores between regular WP pages vs static html pages.
- Done: Wednesday: Deploy beta chat to specific products.

# Bill 20191223
- Checkout Page, Coupons, Free Coupon
- Autoplay to disable completely in Chrome?
-

# IT Team 20191226
Tasks
- Zapier: Drift -> CF
- WT Store Footer
- Send URL of Gatsby S3
- Video about Multi-Product + Product
- Meeting w/ Alex T on CRM API
- Send Google new AMP

# Support Ops 20191230
Tasks
- Scheduled for deletion, keep year and a day
  - In sales, but not from download
  - GDPR
  - Duane / Kate / Carina / Alex T
  - M-Th w/ Alex T for next week 1/6
-

# Bill 20191230
Tasks
- Done: Ask Steph if rebill will be AE
- Flow chart on AC tags.
- CRM API
  - Product list
  - Product details
  - Customer notes.
  - Customer address info.
  -

# Parkside Lending 20191230
- Evolve, Hosting Company
- Migrate to GoDaddy
- Another email recommendation about the website / AWS
  - Bucket of hours.
  - Matt CEO
  -

# Marketing Ops 20200102
Tasks
- ClickFunnels to Main Site
  - Redirect to a custom thank-you page?
  - Add a click event per Google?
- Add field sync CRM + ActiveCampaign
  - Name, Expiration Date, etc on AC instead of using tags.
-

# IT Team 20200102
Tasks
- Team Meeting
- Mass update current customers to an updated product or new product.
-

# Speed Team 20200107
- Spin up test environment for gatsby
- Load Lazy w/ Joseph
- Env w/ Memcached
- Follow w/ AMP

# Marketing Ops 20200108
- New products
  - Keith ?
  - 2 Weeks given
- No Chat Products
-

# Risk Ops | CDRN 20200108
- Josh
- Waiting on Citibank but not catching all.
- Chase: CDRN acquired by Visa?
  - Inheriting Visa's bin, waiting for Chase to catch up.
  - VROL only by Visa so this will be shown soon?
- Josh to send VIN list?
- Josh adding wildcard descriptor for "Warrior Trading"
-

# Support Ops 20200113
- Jan 22nd CRM product launched
- BillR<EMAIL_ADDRESS>new email
- Service Desk: Add who the ticket is assigned to (view from Carina's)
- Tim: Rules for auto notifications based on time.
- Automatically add Carina to CRM / Website
- Kate/Carina: CS Admin
-

# Speed Team 20200114
- Google AMP Course and send to everyone
-

# Team Building 20200116
Ideas
- Releasing to different branches via code pipeline.
- Support
  - Member status: a membre or not, or previous.
  - Product order history
  - Product info
  - Product purchasing API
- CRM customer info for API
  - Billing info
  - Account info
  - Everything about customer.
- Mobile Signup
  - Mobile specific product for mobile app registrations.
  -
CRM request
  - Block multiple 5 day trials, or a notification.
  - Member since field in SSO tokenization.
  -
- CICD
  - Ignore unit tests/steps if no GH repo changes.
  -
- Custom price charging.
-

# Frank 20200117
- Transfer to IRA
- Roll to another 401k
  - 59 1/2, 10% Penalty
- Withdrawing is taxed but NOT rolling.
- Mutual Funds
- Planning Document if I died or somethiing.
  - Power of Attorney
  - Revokable Trust
  - $2500 investment for this service.

# IT Architect 20200121
- API Gateway
- Hydra Authentication
- Traffik works w/ K8s
- Java Springboot
- Freshdesk, AC, CRM
  - Using NodeJS call out to these.
- FeathersJS
- NodeJS http
  - kaoJS
- Generation API keys from AC / Freshdesk
-

- Local by Flywheel
- NGINX on the frontend?
- New Relic
-

# Sales Ops 20200122
Questions
- AC tags?
-
Notes
- Possible for 01/28?
- Meta Menu
-
Tasks
- Done: Reenable for NYE40 Thurs/Fri through 01/28
- Update current chat checkout
- Done: Virtual Seat WP permissions.
  - 199194
  - IC2019VS AC
  - WP already permissioned.
- Redirect to landing page after checkout.
-

# Sterling Ops 20200123
- Jim joining next week about "magic list" from Florida.
- Chart outage
  - Hardware installed, testing done.
  - No client in that and Jim to give ETA
- Margin Tiers
  - Not enabled on new accounts.
  - Still have 4x buying power.
- Metrics
  -

# IT Team 20200123
- Sandbox env creds and prod env creds for AC
  - Steph for creds
  - Find out requirements on new dashboard.
  - I need to be working with AC for API keys.
  - Ask Joseph instead AC
- Bill R on Freshdesk
-

# Support Ops 20200127
- Authorize.net on New Store
  - End of February?
-

# Ticker.tv 20200128
- Get fields from users.
  - Username
  - Email
- Logs, IP
- Cookie values
- Payment Gateway per product.
-

# Speed Team 20200128
- Alternative Rollback
- 7pm Thursday Next Week
- Tutorial AMP from Charleene
- Adsense Status
-

# IT Infrastructure 20200128
- chatroom-service-messag, chatroom-service-classroom
-

# Sales Ops 20200129
- Chatroom landing page verbiages need update.
- Dashboard verbiages
- Joseph: Sidebar graphic from Joseph for checkout
- Joseph: Chat icons for product

# IT Ops 20200130
- API for Learning Path on Monday
- CRM: better interaction of CRM products to decrease need for manual adjustments
  - Another status other than paused?
- CRM: permissioned checkout pages?
- LMS sandbox for Joseph
- Categories through Rest API
- Lifecycle Manager for Ticker.tv
-

# Speed Team 20200204
- Wicked Folders
-

# Sales Ops 20200205
- Futures
  - Update Dashboard
- WP Mega Menu
-

# Risk Ops 20200205
- Exclusion from Load Balancer
- 10% to CMS on Monday, 90% to Braintree
-
-

# Support Ops 20200210
- Arsh options watchlist
- Old Chat
  - Move below New Chat
  - New Words: Enter the Old Small Cap Trading Room
-

# Speed Team 20200211
- Env for mega menu.
-

Winston
- AWS Firehose
-

# IT Team 20200213
- Read Only access for Joseph
- Read over CRM API doc.
-

# IT Team 20200218
- Sandbox AC / Freshdesk
-

# Sales Ops 20200219
- Ross: Login Follow Up w/ Joseph
- Steph: Lists chat chat
-

# Open Enrollment
- Darcy Ricker, Trinet
- TriNet Mobile App
- Download Aetna Summary of Benefits and Coverage (SBC)
-

# ATI 20200228
- WT Dashboard "Manage Button" Toggle
  - Done
- CRM Password-less Checkout?
  - Facebook/Google/etc
  - Email Link
  - Alternatives?
  - Solutions
    - Pay first, then ask for email
    - Confirm Email, Password, Confirm Password

# Support 20200309
- Product Sales
  - Expiration
- Order/data changes by admins/customers
-

Speed Team 20200310
- CloudWatch + RedShift?
- Ticker.tv
  - Spin up dev server

Marketo 20200311
- Kevin Jedreski for technical questions
- Q: Import into Marketo?
- Q: Variables in CRM?
- Launch Pack
  - Core Concepts | Training
- Marketo.com/education
- Webinars: nation.marketo.com/docs/DOC-4312
- Core Concepts | Data Model
-

Sterling Ops 20200312
- Send Sterling API delete call once a month... or two?
- deletion on update API? look sterling

CRM Ops 20200319
Agenda
- Updating current SQL server size.
- Replication
  - Once/hour, every other hour, or 2 times a day?
  - All customer info, except billing, secret info such as password, etc.

IAHSP EU
- Forum
- Events / Calendar
- New Website Design
- 1 year or...
  - 2 year.. less
  - Program ahead of team to have 2 years if leadership wants.
- Wireframe / UX of new IAHSP Europe
- Include<EMAIL_ADDRESS>- Member Directory
  - Add Country
  - First Name, Last Name, City, Country
  - Landing Page

# Marketo Ops 20200602
- DB: Person, Order, Products

# Marketo - Steph
https://secure.warriortrading.com/ati_pro/ati_merchant/admin/customers/details.aspx?id=339825
https://app-sj32.marketo.com/leadDatabase/loadLeadDetail?leadId=970751

if at least one product from a given order is active, display the active/completed/failed

# IAHSP
- Voting WP plugin and shows a ticker.

repository: duaneleem/playground

gha_language: HTML

gha_license_id: MIT

repo_name: duaneleem/playground


text:
[![build status](https://secure.travis-ci.org/senchalabs/connect.png)](http://travis-ci.org/senchalabs/connect)
# Connect

  Connect is an extensible HTTP server framework for [node](http://nodejs.org), providing high performance "plugins" known as _middleware_.

 Connect is bundled with over _20_ commonly used middleware, including
 a logger, session support, cookie parser, and [more](http://senchalabs.github.com/connect). Be sure to view the 2.x [documentation](http://senchalabs.github.com/connect/).

```js
var connect = require('connect')
  , http = require('http');

var app = connect()
  .use(connect.favicon())
  .use(connect.logger('dev'))
  .use(connect.static('public'))
  .use(connect.directory('public'))
  .use(connect.cookieParser())
  .use(connect.session({ secret: 'my secret here' }))
  .use(function(req, res){
    res.end('Hello from Connect!\n');
  });

http.createServer(app).listen(3000);
```

## Middleware

  - [csrf](http://www.senchalabs.org/connect/csrf.html)
  - [basicAuth](http://www.senchalabs.org/connect/basicAuth.html)
  - [bodyParser](http://www.senchalabs.org/connect/bodyParser.html)
  - [json](http://www.senchalabs.org/connect/json.html)
  - [multipart](http://www.senchalabs.org/connect/multipart.html)
  - [urlencoded](http://www.senchalabs.org/connect/urlencoded.html)
  - [cookieParser](http://www.senchalabs.org/connect/cookieParser.html)
  - [directory](http://www.senchalabs.org/connect/directory.html)
  - [compress](http://www.senchalabs.org/connect/compress.html)
  - [errorHandler](http://www.senchalabs.org/connect/errorHandler.html)
  - [favicon](http://www.senchalabs.org/connect/favicon.html)
  - [limit](http://www.senchalabs.org/connect/limit.html)
  - [logger](http://www.senchalabs.org/connect/logger.html)
  - [methodOverride](http://www.senchalabs.org/connect/methodOverride.html)
  - [query](http://www.senchalabs.org/connect/query.html)
  - [responseTime](http://www.senchalabs.org/connect/responseTime.html)
  - [session](http://www.senchalabs.org/connect/session.html)
  - [static](http://www.senchalabs.org/connect/static.html)
  - [staticCache](http://www.senchalabs.org/connect/staticCache.html)
  - [vhost](http://www.senchalabs.org/connect/vhost.html)
  - [subdomains](http://www.senchalabs.org/connect/subdomains.html)
  - [cookieSession](http://www.senchalabs.org/connect/cookieSession.html)

## Running Tests

first:

    $ npm install -d

then:

    $ make test

## Authors

 Below is the output from [git-summary](http://github.com/visionmedia/git-extras).

     project: connect
     commits: 2033
     active : 301 days
     files  : 171
     authors:
      1414	Tj Holowaychuk          69.6%
       298	visionmedia             14.7%
       191	Tim Caswell             9.4%
        51	TJ Holowaychuk          2.5%
        10	Ryan Olds               0.5%
         8	Astro                   0.4%
         5	Nathan Rajlich          0.2%
         5	Jakub Nešetřil          0.2%
         3	Daniel Dickison         0.1%
         3	David Rio Deiros        0.1%
         3	Alexander Simmerl       0.1%
         3	Andreas Lind Petersen   0.1%
         2	Aaron Heckmann          0.1%
         2	Jacques Crocker         0.1%
         2	Fabian Jakobs           0.1%
         2	Brian J Brennan         0.1%
         2	Adam Malcontenti-Wilson 0.1%
         2	Glen Mailer             0.1%
         2	James Campos            0.1%
         1	Trent Mick              0.0%
         1	Troy Kruthoff           0.0%
         1	Wei Zhu                 0.0%
         1	comerc                  0.0%
         1	darobin                 0.0%
         1	nateps                  0.0%
         1	Marco Sanson            0.0%
         1	Arthur Taylor           0.0%
         1	Aseem Kishore           0.0%
         1	Bart Teeuwisse          0.0%
         1	Cameron Howey           0.0%
         1	Chad Weider             0.0%
         1	Craig Barnes            0.0%
         1	Eran Hammer-Lahav       0.0%
         1	Gregory McWhirter       0.0%
         1	Guillermo Rauch         0.0%
         1	Jae Kwon                0.0%
         1	Jakub Nesetril          0.0%
         1	Joshua Peek             0.0%
         1	Jxck                    0.0%
         1	AJ ONeal                0.0%
         1	Michael Hemesath        0.0%
         1	Morten Siebuhr          0.0%
         1	Samori Gorse            0.0%
         1	Tom Jensen              0.0%

## Node Compatibility

  Connect `< 1.x` is compatible with node 0.2.x

  Connect `1.x` is compatible with node 0.4.x

  Connect (_master_) `2.x` is compatible with node 0.6.x

## CLA

 [http://sencha.com/cla](http://sencha.com/cla)

## License

View the [LICENSE](https://github.com/senchalabs/connect/blob/master/LICENSE) file. The [Silk](http://www.famfamfam.com/lab/icons/silk/) icons used by the `directory` middleware created by/copyright of [FAMFAMFAM](http://www.famfamfam.com/).

repository: david-pp/david

repo_name: david-pp/david


text:
---
name: Feature request
about: Suggest an idea for novatel_oem7_driver
title: ''
labels: enhancement
assignees: novatel-applications-engineering

---

**NOTE**
Feature Requests are not to contain personalized information. Use these forms to submit generalized requests about the open source novatel_oem7_driver. All other inquires should be directed to private communications channels with NovAtel Customer Support.

You may reach NovAtel Customer Support by contacting<EMAIL_ADDRESS>Or, you may follow the general Support process explained here: https://docs.novatel.com/OEM7/Content/Front_Matter/Customer_Support.htm

--------------

**Is your feature request related to a problem? Please describe.**
A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]

**Describe the solution you'd like**
A clear and concise description of what you want to happen.

**Describe alternatives you've considered**
A clear and concise description of any alternative solutions or features you've considered.

**Additional context**
Add any other context or screenshots about the feature request here.


text:
---
layout: post
title: Organize Series plugin database optimization
tags: []
excerpt: Organize post series
date: Tue May 19 09:56:50 +0200 2009
---

While looking for posts in the series, this plugin makes two database queries for each post in the series : one to find out if the post is published, and another to get the part number in the series. So if you have 30 posts in the series, you will get 60 queries from this plugin alone on each post belonging to that series. I found this very wasteful, and rewrote one function so that it only uses one database query, no matter what the number of posts in the series. I think the author should be interested...

Basically, in the file series-utility.php, replace the function
    function get_series_order($posts, $postid = 0, $skip = TRUE)
by the following one :
{% highlight php %}
    <?php
      function get_series_order($posts, $postid = 0, $skip = TRUE) {
      global $wpdb;
      if (!isset($posts)) return false; //don't have the posts array so can't do anything
      if ( !is_array( $posts )
      $posts = array($posts);
      $series_posts = array();
      $key = 0;
      foreach ($posts as $spost) {
        if (array_key_exists('object_id', $posts)) {
          if ($key!=0){
            $spost_id .= ",".$spost['object_id'];
          }else{
            $spost_id .= $spost['object_id'];
          }
        } else {
          if ($key!=0){
            $spost_id .= ",".$spost;
          }else{
            $spost_id .= $spost;
          }
        }
        $key++;
      }
      //Optimized : 1 SQL query instead of 2* number ofposts in series//
      $results=$wpdb->get_results("SELECT $wpdb->posts.ID, $wpdb->postmeta.meta_value
      FROM $wpdb->posts LEFT JOIN $wpdb->postmeta
      ON($wpdb->posts.ID = $wpdb->postmeta.post_id)
      WHERE post_status = 'publish' AND $wpdb->posts.ID
      IN (".$spost_id.") AND ener_postmeta.meta_key='".SERIES_PART_KEY."'");
      /* 208 - fix by Matt Porter - to make sure unpublished posts are not made part of a series */
      foreach ($results as $num=>$result) {
        //echo "
resultat".$result->ID.$result>meta_value."
";
        $series_posts[$num]['id'] =$result->ID;
        $series_posts[$num]['part'] = $result->meta_value;
      }
      if (count($series_posts) > 1)
        usort( $series_posts, '_usort_series_by_part' );
      return $series_posts;
    }
    ?>
{% endhighlight %}

And there you go, a faster blog...

extension: markdown

gha_language: SCSS


text:
# TradingView Charting Library and Angular 5 Integration Example

The earliest supported version of the charting library for these examples is `v23.043`.

## How to start

1. Check that you can view https://github.com/tradingview/charting_library/. If you do not have access then you can [request access to this repository here](https://www.tradingview.com/HTML5-stock-forex-bitcoin-charting-library/).
1. Install dependencies with `npm install`.
1. Copy the charting library files
	1. If you are able to run bash scripts then the `copy_charting_library_files.sh` script can be used to copy the current stable version's files.
	1. If you are not able to run bash scripts then do the following:
		1. Copy `charting_library` folder from https://github.com/tradingview/charting_library/ to `/src/assets`.
		1. Copy `datafeeds` folder from https://github.com/tradingview/charting_library/ to `/src/assets`.
1. Run `./node_modules/.bin/ng serve` (use `"./node_modules/.bin/ng" serve` in Windows) for a dev server and navigate to `http://localhost:4200/`.

## What is Charting Library

Charting Library is a standalone solution for displaying charts. This free, downloadable library is hosted on your servers and is connected to your data feed to be used in your website or app. [Learn more and download](https://www.tradingview.com/HTML5-stock-forex-bitcoin-charting-library/).

## What is Angular

Angular is a platform that makes it easy to build applications with the web. Angular combines declarative templates, dependency injection, end to end tooling, and integrated best practices to solve development challenges. Angular empowers developers to build applications that live on the web, mobile, or the desktop. [Learn more](https://angular.io/docs).

## About This Project

This project was generated with [Angular CLI](https://github.com/angular/angular-cli) version 13.1.2.

repository: tradingview/charting-library-examples

gha_language: Ruby

repo_name: tradingview/charting-library-examples


text:
# socket-server

socket-server is a swoole based PHP tcp socket server.

it exposes several incredibly sophisticated services which were never seen before.

## Installation
 - install [docker](https://docs.docker.com/get-docker/) and [docker-compose](https://docs.docker.com/compose/install/)
 - run `docker-compose up`

## Usage

Use telnet to connect to the running server
```bash
telnet <IP_ADDRESS> 1111
```

Select a command (number) from the menu
```bash
Trying <IP_ADDRESS>...
Connected to <IP_ADDRESS>.
Escape character is '^]'.

---------------
--- Welcome ---
---------------

[1] disk space
[2] ping avg on <IP_ADDRESS>
[3] google top results
[4] exit

Enter:
```

## What's missing

- testing would be nice
- separating the pinging to a different process (maybe even to it's own container)
- better logging
- monitoring for the server state
- cleaner session termination

## Author
[Ami<EMAIL_ADDRESS>
## Contributing
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests as appropriate.

## License
[MIT](https://choosealicense.com/licenses/mit/)

repository: ami-m/socket-server

repo_name: ami-m/socket-server


text:
# REACT-NATIVE-BIP39
An adjusted version of [Bitcoinjs Bip39](https://github.com/bitcoinjs/bip39)
## Installation
``` bash
npm install @medardm/react-native-bip39
```

license: ISC


text:
# Alert | Accessibility ♿

This report is adapted to list the [WAI-ARIA Authoring practices for Alerts](https://www.w3.org/TR/wai-aria-practices-1.2/#alert) supported by Chakra UI for the `CAlert` component.

### Description
An alert is an element that displays a brief, important message in a way that attracts the user's attention without interrupting the user's task. Dynamically rendered alerts are automatically announced by most screen readers, and in some operating systems, they may trigger an alert sound. It is important to note that, at this time, screen readers do not inform users of alerts that are present on the page before page load completes.

#### Components
`@chakra-ui/vue` exports 4 Alert related components:
- `CAlert`
- `CAlertIcon`
- `CAlertTitle`
- `CAlertDescription`

### `CAlert` Keyboard Interaction
Not applicable. This is because the `CAlert` component should not interfere with the users ability
to continue working. Therefore, displaying the alert does not affect keyboard focus.

### `CAlert` WAI-ARIA Roles, States, and Properties:
- [x] The `CAlert` component has a `role` of `alert`.

Noticed a bug or inconsistency with this component? [Open an issue](https://github.com/chakra-ui/chakra-ui-vue/issues/new/choose)

repository: chakra-ui/chakra-ui-vue

branch_name: refs/heads/develop

gha_language: JavaScript

repo_name: chakra-ui/chakra-ui-vue


text:
# Integration with Atlantis Pull Request Automation

[Atlantis](https://www.runatlantis.io/) is a pull request automation system designed to control Terraform execution from Github commits.

You can integrate Terrascan into an Atlantis setup using one of the two ways:

* Method 1: Atlantis [Workflow-based](https://www.runatlantis.io/docs/custom-workflows.html) integration which sends scan requests to an independently running terraform server
* Method 2: Custom Atlantis container image which has an integrated Terrascan

In either scenario, the configuration of Atlantis varies from installation to installation. For instructions to install, configure, and use Atlantis, see the [Atlantis documentation](https://www.runatlantis.io/docs/).

## Method 1: Workflow-based integration
In this method, you can modify or create a custom workflow for Atlantis so your repositories will be scanned by Terrascan as part of the pull request automation.

**Requirements**

The following requirements must be met before starting the integration workflow:

* The atlantis server must have TCP connectivity to where the terrascan server is running.
* The `curl` command must be installed on the system so the `terrascan-remote-scan.sh` script can make the scan request. Atlantis's [docker image](https://hub.docker.com/r/runatlantis/atlantis/) has curl preinstalled.

## Integration steps for Workflow based integration

- Modify Workflow
- Configure the Script
- Run Atlantis

### Modify Workflow

1. Modify your workflow to call `terrascan-remote-scan.sh` during the plan stage.
2. See the 'plan' detailed below:
  - the first three `run: terraform` commands are the default for an atlantis workflow.
  >**Note**: The values for the variables `$WORKSPACE` and `$PLANFILE` referenced in the second and third run commands in the yaml below are automatically provided by atlantis
  - The fourth `run terrascan-remote-scan.sh` initiates the Terrascan scan request.

>**Note**: By default, the `terrascan-remote-scan.sh` script can be found under the `scripts` directory in this project; copy this to a location where it can be executed by the Atlantis server.
If the `terrascan-remote-scan.sh` script is not in the directory where the Atlantis server command is being run to, you will have to specify the path to the script in the fourth run command.

```yaml
repos:
- id: /.*/
  workflow: terrascan

workflows:
  terrascan:
    plan:
      steps:
        - run: terraform init -input=false -no-color
        - run: terraform workspace select -no-color $WORKSPACE
        - run: terraform plan -input=false -refresh -no-color --out $PLANFILE
        - run: terrascan-remote-scan.sh
```
### Script configuration

Modify the `terrascan-remote-scan.sh` script according your environment. The script is [located here](https://github.com/accurics/terrascan/tree/master/scripts). Open the script with your any editor of your choice and review the following six settings which is found at the top of the file:

```
TERRASCAN_SERVER=<IP_ADDRESS>
TERRASCAN_PORT=9010
IGNORE_LOW_SEVERITY=false
IAC=terraform
IAC_VERSION=v14
CLOUD_PROVIDER=aws
```
Descriptions of these settings are as follows:
* `TERRASCAN_SERVER` is the hostname or IP address of the host running the terrascan server. This will be used by the script to submit the scan request.
* `TERRASCAN_PORT` is the TCP port which Terrascan server is listening on. By default, this is `9010`.
* `IGNORE_LOW_SERVERITY` allows you to specify the scan response for low-severity findings in the code. During a scan if the `terrascan-remote-scan.sh` should fail a build if a low-severity finding is found. Some users will want to set this to `true` so they may ignore low-severity findings.
* `IAC`, `IAC_VERSION`, and `CLOUD_PROVIDER` are terrascan options. Descriptions and valid values can be found by running `terrascan scan -h`.

### Running atlantis
Run Atlantis with the `terrascan-workflow.yaml` as a [server-side repo configuration](https://www.runatlantis.io/docs/server-side-repo-config.html). The command for this depends on how you choose to [deploy Atlantis](https://www.runatlantis.io/docs/deployment.html#deployment-2).
If running the Atlantis binary directly, use the following command:

```bash
$ atlantis server \
--atlantis-url="$URL" \
--gh-user="$USERNAME" \
--gh-token="$TOKEN" \
--gh-webhook-secret="$SECRET" \
--repo-allowlist="$REPO_ALLOWLIST" \
--repo-config=terrascan-workflow.yaml
```
> **Note**: The variables in the example above must be configured separately using `export` or similar shell methods.

[comment]: <> (Instructions/link to configure would be useful here)

**Important**: Before the first pull request is processed, run Terrascan in `server` mode using the following command:

```
terrascan server
```
### Automated scanning and results

When the systems are running, if Atlantis is initiated either via a pull request, or via a comment of `atlantis plan`, Terrascan will be also be invoked as part of the atlantis plan flow. Scan results are reported as part of the pull request as comments, this notifies the reviewers before approving a requests.  If any issues are found the test will be marked as failed.

## Method 2: Custom Atlantis Container

Terrascan offers a custom container built on top of the official Atlantis container image, which allows users to run IaC scans with Terrascan, in addition to the usual atlantis usage. There's a built-in atlantis workflow configured inside the
container which is ready to be used.
The default `workflow.yaml` file used is the `atlantis/workflow.yaml` in the Terrascan repo.
Alternatively, you can also override that default workflow using the `--repo-config` flag.

### Steps to use the custom Atlantis container

In code repository, usage is exactly the same as atlantis, add a comment `atlantis plan` and `atlantis plan` to your Pull Requests to trigger the custom atlantis-terrascan workflow.

##### To use the default built-in container image:

```
docker pull accurics/terrascan_atlantis
```

##### To build your own container image:
```
docker build ./integrations/atlantis -t <image_name>
```

### Run the container:

```bash
docker run \
--env-file=<.env-file> \
-p 4141:4141 \
-v <pwd>/config_data/:/etc/terrascan/ \
accurics/terrascan_atlantis server \
--gh-user="$USERNAME" --gh-token="$TOKEN" --gh-webhook-secret="$SECRET" \
--repo-allowlist="$REPO_ALLOWLIST" \
-c /etc/terrascan/config.toml
```

The syntax of the Atlantis server command here is same as in [atlantis docs](https://www.runatlantis.io/docs/), except for an optional `-c` flag which can be used to specify the file path for the toml config to be used by Terrascan. Another way to provide the toml config filepath would be the TERRASCAN_CONFIG environment variable. You need to provide all the environment variables that terraform requires to operate with your respective cloud providers.

> **Note**: As a good practice, Terrascan recommends use of a [specific tag](https://hub.docker.com/r/accurics/terrascan_atlantis/tags) of the container image rather than the latest tag.

[comment]: <> (Moved the workflow yaml note to above where its mentioned)

### Running a scan

With everything configured, a local Terrascan scan will be triggered as part of the Atlantis plan workflow.

repository: HritvikM/terrascan

repo_name: HritvikM/terrascan


text:
# Term Transitions

Each Classy VM is assigned a hostname that is re-used for a course. As Classy is not designed to run multiple instances on a host, term transitions require an exact end-date. The end-date marks a time that data from the prior term will no longer be modified and can safely be archived on a network storage location without disruption to a course.

[GitHub re-configuration](#github-term-transition-checklist) and [VM re-configuration](#vm-term-transition-checklist) must occur.

## Back-up and Archive Network Locations

- Database: `/cs/portal-backup/$HOSTNAME/classy/$org/`
- Grading runs: `/cs/portal-backup/$HOSTNAME/classy/$org/runs-$(date +\%Y\%m\%dT\%H\%M\%S)`

## Archive Data Database

There are two types of data to archive:

1. MongoDB `gzip` data dump
2. Container grading run tarball

MongoDB offers the `mongodump` tool to dump the database and automatically export the database dump in `gzip` format. The database username and password are required for this operation, which can be found in the `.env` file in the `/opt/classy` folder.

The grading runs of a course consist of student assignments, log information, and results that are stored on the Classy VM filesystem in the path specified in the `HOST_DIR` attribute in the `.env` file.

Two scripts can perform the database dump and grading run archive operations:

- `/opt/classy-scripts/archive-classy-runs.sh`
- `/opt/classy-scripts/backup-classy-db.sh`

A CRON job is configured to automatically back up the database and grading run data. After the end-date of the semester transition, it is no longer necessary to retain the back-ups created by the CRON jobs. Hence, delete all the database and grading run back-ups *prior* to the last back-up and archive of the database.

## VM Term Transition Checklist

- [ ] Staff and faculty have agreed on an end-date when Classy archiving can take place without disrupting course operations
- [ ] Database has been backed-up to **Back-up storage location**
  - Script: `/opt/classy-scripts/backup-classy-db.sh`
- [ ] Grading runs have been archived to **Archive storage location**
  - Script: `/opt/classy-scripts/archive-classy-runs.sh`
- [ ] Once database has been backed-up, host MongoDB volume mount location has been deleted
  - Command: `rm -rf /var/opt/classy/db/*`
- [ ] Once grading runs have been archived, host filesystem run have been deleted
  - Command: `rm -rf /var/opt/classy/runs/*`
- [ ] ClassList API **sections** and **term** have been updated in `/opt/classy/.env` file.
  - Course sections found here: [Course Schedule](https://courses.students.ubc.ca/cs/courseschedule?pname=subjarea&tname=subj-department&dept=CPSC)
- [ ] A new GitHub organization namespace has been created for the term  (ie. **cpsc210-2019w-t1**)
  - Instructions: [Add Students and Staff to GitHub Organization](/docs/tech-staff/githubsetup.md#add-students-and-staff-to-github-organization)
- [ ] Only the last two database and grading run back-ups are retained
  - All grading run and database back-ups prior to the last back-ups have been deleted

## GitHub Term Transition Checklist

- [ ] If another course is being offered next term, configure a new GitHub organization for the term
- [ ] A new OAuth application has been created under the new GitHub organization and integrated in the `/opt/classy/.env` file
  - Instructions: [Setup GitHub OAuth](/docs/tech-staff/githubsetup.md#setup-github-oauth)
- [ ] An instructor may request additional GitHub configuration steps, such as adding TAs as organization owners

gha_language: TypeScript


text:
---
title: Deploying a Containerized Gitlab Instance with Kubernetes
author: jbrooks
date: 2015-01-15 23:42:33 UTC
tags:
- docker
- kubernetes
- centos
- gitlab
categories:
- Blog
published: true
comments: true
---

Back in November, I wrote about how to [try out Kubernetes](http://www.projectatomic.io/blog/2014/11/testing-kubernetes-with-an-atomic-host/), the open source system for managing containerized applications across multiple hosts, using Atomic Hosts. In that post, I walked through a deployment of the Kubernetes project's multicontainer "Hello World" application.

This time, I thought I'd explore running a more real-world application on Kubernetes, while looking into a few alternate methods of spinning up a Kubernetes cluster.

For the application, I picked Gitlab, an open source code collaboration platform that resembles and works like the popular Github service. I run a Gitlab instance internally here at work, and I wanted to explore moving that application from its current, virtual machine-based home, toward a shiny new containerized future.

READMORE

### Gitlab, Dockerized
The Gitlab project [provides a Dockerfile](https://gitlab.com/gitlab-org/gitlab-ce/tree/master/docker) for creating a containerized "Omnibus" instance of the application that smushes together a Redis key-value store, Postgres database, and Nginx web server into a single container. However, since Docker best practices dictate that individual application elements be deployed as separate containers, I turned to a [multi-container installation option](https://github.com/sameersbn/docker-gitlab) created by community member [Sameer Naik](https://twitter.com/sameersbn).

I set out first to convert Sameer's implementation from Ubuntu to [CentOS](https://github.com/jasonbrooks/docker-gitlab), which wasn't too terribly complicated and mostly involved translating Debian-style package names to their RPM-world equivalents. The trickiest bits of the conversion involved editing the bash scripts used to install Gitlab from source and perform configuration chores in the Gitlab container. Looking ahead, I'm interested in taking a look at Ansible as an alternative to these somewhat-ungainly bash scripts.

For the Redis and Postgres containers required by Gitlab, I simply reached for a pair of off-the-shelf Dockerfiles provided by the CentOS project in its [CentOS-Dockerfiles](https://github.com/CentOS/CentOS-Dockerfiles) repository.

### Assembling a Kubernetes Cluster

Once I had a Dockerized, CentOS-based set of containers to work with, I turned to bringing up a Kubernetes cluster. The [Ansible+Atomic method](http://www.projectatomic.io/blog/2014/11/testing-kubernetes-with-an-atomic-host/) I wrote about last time still works fine, but I wanted to explore a couple other Kubernetes deployment options.

I looked into three new methods for turning up a Kubernetes cluster: [Vagrant](https://github.com/GoogleCloudPlatform/kubernetes/blob/master/docs/getting-started-guides/vagrant.md), [OpenStack Heat](https://github.com/larsks/heat-kubernetes), and Google's [Container Engine](https://cloud.google.com/container-engine/).

I didn't manage to get a cluster up and running with Vagrant, at least not with my chosen provider of libvirt. The scripts that ship with Kubernetes for Vagrant are hard-coded to the VirtualBox provider. I typically test within a KVM environment, and while nesting KVM within KVM works well, VirtualBox within KVM does not, and I wasn't interested in parting with a bare metal machine for this test. In any case, I stumbled across about [running Vagrant with libvirt on Fedora](http://blog.obnox.de/vagrant-with-lxc-and-libvirt-on-fedora/) that I expect will come in handy soon.

If you're a VirtualBox+Vagrant adherent, though, this looks like a pretty easy way to get up and running with a test cluster.

Getting Kubernetes running with OpenStack Heat was pretty simple, after I ensured that I'd outfitted my OpenStack cloud not only with Heat itself, but also the Heat CloudWatch API, on which this stack depends. Also, in order to use Atomic Host instances for my master and minions, I had to create a snapshot of a [Fedora Atomic](https://getfedora.org/en/cloud/download/) or [CentOS Atomic](http://buildlogs.centos.org/monthly/7/) instance on which I'd run `sudo atomic upgrade`, as this Heat stack requires the recently-added Flannel for networking.

From there, I needed only clone the [heat-kubernetes](https://github.com/larsks/heat-kubernetes) repository, create a `local.yaml` file corresponding to my environment, and run `heat stack-create -f kubecluster.yaml -e local.yaml my-kube-cluster` to kick off the stack.

If you don't have an OpenStack cloud handy, it's pretty simple to spin up a new Kubernetes cluster via Google's [Container Engine](https://cloud.google.com/container-engine/), which automates the creation of a set of VMs running Debian and hosting the necessary bits for Kubernetes' master and minions.

### Deploying Gitlab

With a Kubernetes cluster of our choice ready for action, the steps required to start up an instance of Gitlab are pretty similar to those for the Kubernetes "Hello World" guestbook application.

First, clone my [docker-gitlab](https://github.com/jasonbrooks/docker-gitlab) repository:

````
git clone https://github.com/jasonbrooks/docker-gitlab.git
````

Alongside the Dockerfile for Gitlab, and a set of scripts and files required for building that container, this repository contains a set of Kubernetes json files for defining the pods and services for gitlab, redis and postgresql.

I've pushed containers for redis, postgresql and gitlab to the Docker hub under my user name, jasonbooks, but you can follow the build instructions in the repo's README to build and push your own containers, if you wish. Just swap out `jasonbrooks` for your own registry location in the "pod" json files to use the containers you've built. You can also edit the json files to choose a new database password.

Kick off the commands below to get redis and postgresql running. It's important to start these up before starting gitlab, because pods are only aware of the environment variables of previously-started pods, and this is how gitlab will figure out where its database and key value store can be found:

````
kubectl --server=http://KUBE_MASTER:8080 create -f redis-pod.json
kubectl --server=http://KUBE_MASTER:8080 create -f redis-service.json
kubectl --server=http://KUBE_MASTER:8080 create -f postgres-pod.json
kubectl --server=http://KUBE_MASTER:8080 create -f postgres-service.json
````

Then, monitor `kubectl --server=http://KUBE_MASTER:8080 get pods` until the redis and postgresql pods are `Running`:

````
NAME                IMAGE(S)               HOST                LABELS              STATUS
redis               jasonbrooks/redis      <IP_ADDRESS>/           name=redis          Running
postgresql          jasonbrooks/postgres   <IP_ADDRESS>/           name=postgresql     Running
````

Now, start up the Gitlab pod:

````
kubectl --server=http://KUBE_MASTER:8080 create -f gitlab-pod.json
````

After another run of `kubectl --server=http://KUBE_MASTER:8080 get pods` indicates that the gitlab pod is running, you can monitor the initialization of gitlab with the command `kubectl --server=http://KUBE_MASTER:8080 log gitlab`. When the logs indicate that `sidekiq`, `unicorn`, `cron`, `nginx`, and `sshd` are up and running, you should be able to access the Gitlab web interface from port 10080 on your minion, and Gitlab's ssh from port 10022.

Now, minions can change, and we probably prefer to stick with the default ports 80 and 22 for web and ssh. Here's where the service files for Gitlab come into play. We need more than one service file for our Gitlab pod because each service can only handle a single port (for now, at least).

You can edit the files `gitlab-service-http.json` and `gitlab-service-ssh.json` and replace `STATIC_IP_HERE` with a static IP of your choice. Then, fire off a couple of commands to create the services:

````
kubectl --server=http://KUBE_MASTER:8080 create -f gitlab-service-ssh.json
kubectl --server=http://KUBE_MASTER:8080 create -f gitlab-service-http.json
````

To make this actually work, you'll need to figure out a mechanism for sending traffic directed toward your static IP to your minions. On GCE, which offers a built-in load balancer feature, I set a forwarding rule to send traffic for ports 22-80 to my pool of minions. I imagine I could configure OpenStack and its [load balancer-as-a-service](http://docs.openstack.org/api/openstack-network/2.0/content/lbaas_ext.html) to perform the same task, but I haven't tried that out yet.

### Next Steps

So, am I ready to ditch my virtual machine for a fancy new Docker/Kubernetes based Gitlab installation? Not quite yet. I have a few more areas to understand, so keep an eye out for an upcoming blog post that covers these and other issues:

* Data persistence w/ Kubernetes -- this appears to be a matter of referencing volumes in the pod definition files
* Work out an application migration and update strategy
* Settle on load-balancing tooling and configuration
* Clean up my gitlab container configuration scripts, probably with Ansible

If you run into trouble following this walkthrough, I’ll be happy to help you get up and running or get pointed in the right direction. Ping me at jbrooks in #atomic on freenode irc or [@jasonbrooks](https://twitter.com/jasonbrooks) on Twitter. Also, be sure to check out the [Project Atomic Q&A site](http://ask.projectatomic.io/en/questions/).

repository: mijos/atomic-site

gha_license_id: NOASSERTION

repo_name: mijos/atomic-site


text:
# unity-packman
A tiny package dependency manager for Unity, powered by Github

## Why package manager for Unity?
I am working with many Unity projects, and most of them use somewhat shared packages.
but there was no clever way to support package dependencies for programmers yet. so I started this project.

with `unity-packman`, all package dependencies will be installed in `Assets/Plugins/packman-pkgs` folder.
you don't need to copy packages manually.

## Requirements
- nodejs (>= 6.0.0) / npm
- git

## Getting Started
In your project directory (parent of Unity `Assets` folder).
```bash
npm install -g unity-packman
```

Below command will create `packman.json` for your project.
```bash
unity-packman init
```
Then, now you can install dependency like this:
```bash
unity-packman install appetizermonster/Unity3D-Co
```

## Extra Commands
- Install All Dependencies in `packman.json`
```bash
unity-packman install
```

- Remove Installed Dependency
```bash
unity-packman remove appetizermonster/Unity3D-Co
```

- Update `.gitignore` for unity-packman
```bash
unity-packman gitignore
```

- Copy modified assets back into repository directory (to commit changes)
```bash
unity-packman copyback appetizermonster/Unity3D-Co
```

## Structure of `packman.json`
```javascript
{
  "name": "Unity3D-Co",                           // Package Name
  "export": "Assets/Co",                          // Export Directory
  "dependencies": [
    "appetizermonster/Unity3D-RecompileDisabler"  // Package URI
  ]
}
```

## Examples of Package URI
- Default

  ```
  appetizermonster/Unity3D-Co
  ```

- Specific Commit (with SHA1 Hash)

  ```
  appetizermonster/Unity3D-Co?commit=6236ae6ed9e57de626b31e8d1c0957e074cf9331
  ```

- Specific Branch

  ```
  appetizermonster/Unity3D-Co?branch=develop
  ```

- Specific Tag

  ```
  appetizermonster/Unity3D-Co?tag=v0.0.1
  ```

## TODO
- `prune` command

## Example Packages
- [appetizermonster/Unity3D-Co](https://github.com/appetizermonster/Unity3D-Co)
- [appetizermonster/Unity3D-RecompileDisabler](https://github.com/appetizermonster/Unity3D-RecompileDisabler)

## Contribution
Any contributions are welcome!, Please open an issue!

## License
MIT

repository: kennelbound-unity/unity-packman

repo_name: kennelbound-unity/unity-packman


text:
# FD_spheres_variable_diffusivity
Finite difference discretization scheme for diffusion in a sphere with variable diffusivity

[![DOI](https://zenodo.org/badge/92102324.svg)](https://zenodo.org/badge/latestdoi/92102324)

![GUI screenshot](FD_spheres_variable_diffusivity.png)

## Overview
This code solves the PDE for Fickian diffusion with variable diffusivity within a radially symmetric sphere. The PDE is solved numerically using method of lines, the spherical finite difference discretization scheme defined and analyzed in the reference, and any built-in MATLAB ODE solver. Examples are provided for variable diffusivity cases I-IV presented in the reference listed below. The use of ode45 solver is shown in this code. Any ODE solver could be selected.

## Finite Difference Discretization Scheme for Spherical Diffusion with Variable Diffusivity
### Authors
Ashlee N. Ford Versypt, School of Chemical Engineering, Oklahoma State University
<EMAIL_ADDRESS>
Richard D. Braatz, Department of Chemical Engineering, Massachusetts Institute of Technology
<EMAIL_ADDRESS>
## Reference
When using this software, please cite:

A. N. Ford Versypt & R. D. Braatz, Analysis of finite difference discretization schemes for diffusion in spheres with variable diffusivity, Computers & Chemical Engineering, 71 (2014) 241-252, https://doi.org/10.1016/j.compchemeng.2014.05.022

## Diffusivity cases (defined computationally in FD_spheres_variable_diffusivity.m)
DCASE = 1;
Case I: constant diffusivity with alpha = alpha0

DCASE = 2;
Case II: time-dependent diffusivity
alpha = alpha0 for t =< tau
and
alpha = alpha0*exp(k*(t - tau)) for t > tau

DCASE = 3;
Case III: spatially dependent diffusivity
alpha = alpha0*r^2

DCASE = 4;
CASE IV: concentration-dependent diffusivity
alpha = alpha0*exp(k-k*c)

## Code
solve_FD_spheres_variable_diffusivity.m solves the diffusion PDE in spherical coordinates for c(r,t) with variable diffusivity defined by DCASE

FD_spheres_variable_diffusivity uses the finite difference discretization scheme defined in the reference as Scheme 1 and the variable diffusivity Cases I-IV analyzed in that work.


text:
# Стерлядь!!!

Another Yandex Translate API client.

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'sterlet'
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install sterlet

## Usage

```ruby
> require 'sterlet'
=> true
> client = Sterlet::Client.new(ENV['STERLET_API_KEY'])
> client.langs
=> {:af=>"Afrikaans", :am=>"Amharic", ... }
> client.dirs
=> [[:az, :ru], [:be, :bg], ...]
> client.detect('Любить жмыхнуло братан')
=> :ru
irb(main):007:0> client.translate('Любить жмыхнуло братан', to: :en)
=> "Love smahnula bro"
> client.translate('Любить жмыхнуло братан', to: :en, from: 'bg')
=> "Love smahnula love"
```

## Development

After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).

## Contributing

Bug reports and pull requests are welcome on GitHub at https://github.com/RGBD/sterlet-rb.

## License

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

repository: RGBD/sterlet-rb

repo_name: RGBD/sterlet-rb


text:
---
slug: /en/sql-reference/statements/exists
sidebar_position: 45
sidebar_label: EXISTS
---

# EXISTS Statement

``` sql
EXISTS [TEMPORARY] [TABLE|DICTIONARY] [db.]name [INTO OUTFILE filename] [FORMAT format]
```

Returns a single `UInt8`-type column, which contains the single value `0` if the table or database does not exist, or `1` if the table exists in the specified database.

repository: ClickHouse/ClickHouse

repo_name: ClickHouse/ClickHouse


text:
# Introduction

KafkaStreams4s is a library for writing Kafka Streams programs while leveraging the [cats](https://github.com/typelevel/cats) ecosystem.

## Quick example

This example uses the `kafka-streams4s-circe` module, but the code should look similar even if you do not use circe or even JSON.

For this example let's consider a use case where we track movies and movie sales and want to figure out if we can find trends for movie genres.
Modeling this as Scala case classes we write the following:

```scala mdoc:silent
import java.util.UUID

case class Movie(title: String, genre: String)
case class Purchase(movieId: UUID, amount: Int, user: String)
```

In order for us to use these case classes with `kafka-streams4s-circe`, we'll need to define `Encoder`s and `Decoder`s for them.

```scala mdoc:silent
import io.circe.{Encoder, Decoder}

implicit val movieDecoder: Decoder[Movie] = Decoder.forProduct2("title", "genre")(Movie.apply _)
implicit val movieEncoder: Encoder[Movie] = Encoder.forProduct2("title", "genre")(m => (m.title, m.genre))

implicit val purchaseDecoder: Decoder[Purchase] = Decoder.forProduct3("movieId", "amount", "user")(Purchase.apply _)
implicit val purchaseEncoder: Encoder[Purchase] =
  Encoder.forProduct3("movieId", "amount", "user")(p => (p.movieId, p.amount, p.user))
```

We will assume here that there exist two kafka topics `example.movies` and `example.purchases` which emit json records.
Next, we will want to create a `CirceTable` for the two topics we want to use for our programs.
A `CirceTable[K, V]` is a wrapper around a `KTable[K, V]` and includes all the necessary codecs so that Kafka Streams is able to serialize and deserialize our records without having to pass around any codecs explicitly. Simply put, we can create a `CirceTable[K, V]` for any `K` and `V` that have a circe `Encoder` and `Decoder` in scope.

```scala mdoc:silent
import compstak.kafkastreams4s.circe.CirceTable
import org.apache.kafka.streams.StreamsBuilder

val sb = new StreamsBuilder

val movies = CirceTable[UUID, Movie](sb, "example.movies")
val purchases = CirceTable[UUID, Purchase](sb, "example.purchases")
```

Now, what we'll want to do is join the two topics, filter out some genres and accumulate the results into a `Map` of genre to number of purchases.

```scala mdoc:silent
val withoutOther: CirceTable[UUID, Movie] = movies.filter(_.genre != "Other")
val pairs: CirceTable[UUID, (Purchase, Movie)] =
  purchases.join(withoutOther)(purchase => purchase.movieId)((purchase, movie) => (purchase, movie))

val result: CirceTable[String, Int] =
  pairs.scanWith { case (id, (purchase, movie)) => (movie.genre, purchase.amount) }(_ + _)

```

Here we first filter out all the movies that are tagged with the `"Other"` genre.
Then we join the movies and purchases topics and lastly we use the `scanWith` operation to select a new KV-pair and then pass a function to aggregate the result.
Now, all that's left is to direct the result into an output topic `example.output` and run the program

```scala mdoc:silent
import scala.concurrent.ExecutionContext
import cats._, cats.implicits._
import cats.effect._, cats.effect.implicits._
import compstak.kafkastreams4s.Platform
import org.apache.kafka.streams.Topology
import java.util.Properties
import java.time.Duration

val props = new Properties //in real code add the desired configuration to this object.

val topology: IO[Topology] = result.to[IO]("example.output") >> IO(sb.build())

val main: IO[Unit] =
  topology.flatMap(topo => Platform.run[IO](topo, props, Duration.ofSeconds(2))).void
```

`compstak.kafkastreams4s.Platform` gives us a function `run` to run Kafka Streams programs and takes a topology, java properties and a timeout after which the stream threads will be shut off.

## Testing your topologies

KafkaStreams4s comes with a testing module that allows us to test our kafka streams programs without even spinning up a kafka cluster.
To start using it include the `kafka-streams4s-testing` module in your `build.sbt`.
It's built upon `kafka-streams-test-utils` and should give us a good amount of confidence in our streams logic.

First we will create a test driver using our topology defined earlier:

```scala mdoc:silent
import cats.effect.Resource
import compstak.kafkastreams4s.testing.KafkaStreamsTestRunner
import org.apache.kafka.streams.TopologyTestDriver

val driver: Resource[IO, TopologyTestDriver] =
  Resource.eval(topology).flatMap(KafkaStreamsTestRunner.testDriverResource[IO])

```

Then we'll setup some inputs for our two topics:

```scala mdoc:silent
import compstak.kafkastreams4s.circe.CirceCodec

val testMovies = List(
  UUID.fromString("150ac164-a4dd-4809-9e2f-fc092edb9d1d") -> Movie("The Godfather", "Crime"),
  UUID.fromString("1312c871-dd07-43a7-ae7b-3a74e0c9ce6d") -> Movie("Schindler's List", "Drama"),
  UUID.fromString("b6168e9a-a871-4712-a15b-0261edc7c9d2") -> Movie("Being John Malkovich", "Other")
)

val testPurchases = List(
  UUID.fromString("faad4c27-39d6-41df-9d97-102dc5b0bc93") -> Purchase(UUID.fromString("b6168e9a-a871-4712-a15b-0261edc7c9d2"), 2, "JohnDoe42"),
  UUID.fromString("310a790e-7df4-4cbb-91f8-42bcf998b9e5") -> Purchase(UUID.fromString("150ac164-a4dd-4809-9e2f-fc092edb9d1d"), 1, "MarkB98"),
  UUID.fromString("5d00d33e-82c4-418e-b776-46b16bd13508") -> Purchase(UUID.fromString("1312c871-dd07-43a7-ae7b-3a74e0c9ce6d"), 1, "JaneDoe"),
  UUID.fromString("0e36dd2f-e3db-4b1e-af45-52f8bc27d65f") -> Purchase(UUID.fromString("150ac164-a4dd-4809-9e2f-fc092edb9d1d"), 3, "NinaD14"),
)

def pipeIn(driver: TopologyTestDriver): IO[Unit] =
  KafkaStreamsTestRunner.inputTestTable[IO, CirceCodec](driver, "example.movies", testMovies: _*) >>
  KafkaStreamsTestRunner.inputTestTable[IO, CirceCodec](driver, "example.purchases", testPurchases: _*)

```

Next, we'll get out the values from the output topic using a different function from the `KafkaStreamsTestRunner`.

```scala mdoc
import cats.effect.unsafe.implicits.global

def pipeOut(driver: TopologyTestDriver): IO[Map[String, Int]] =
  KafkaStreamsTestRunner.outputTestTable[IO, CirceCodec, String, Int](driver, "example.output")

driver.use(d => pipeIn(d) >> pipeOut(d)).unsafeRunSync
```


text:
---
title: GetInstallPath
keywords:
last_updated: March 18, 2017
tags:
summary: Get a string representing the path in which QuantSA is installed.
sidebar: excel_sidebar
permalink: GetInstallPath.html
folder: excel
---

## Description
Get a string representing the path in which QuantSA is installed.

<!--HUMAN EDIT START-->

<!--## Details-->

<!--HUMAN EDIT END-->

## Example Sheet

    CreateProductFromFile.xlsx

## Arguments

<!--HUMAN EDIT START-->

<!--## Validation-->

<!--HUMAN EDIT END-->

repository: JamesLTaylor/QuantSA

gha_language: C#

repo_name: JamesLTaylor/QuantSA


text:
# Google Cloud AutoML Natural Language for Text Classification

## Building a Language Toxicity Classification Model

| | |
|-|-|
|__Title__| Google Cloud AutoML Natural Language for Text Classification
|__Author__ | __Ekaba Bisong__
Google Developer Expert in Machine Learning
 Google Certified Professional Data Engineer
|__Website__ | #

Google Cloud AutoML for Natural Language provides the platform for designing and developing custom language models for language recognition use-cases. This project uses Google Cloud AutoML for Natural Language to develop an end-to-end language toxicity classification model to identify obscene text. The concept of neural architecture search and transfer learning are used under the hood to find the best network architecture and the optimal hyperparameter setting that improves the performance of the model.

## About the Dataset
The data used in this project is from the Toxic Comment Classification Challenge on Kaggle by Jigsaw and Google. The data is modified to have a sample of 16,000 toxic and 16,000 non-toxic words as inputs to build the model on AutoML NLP.

The dataset is hosted on Kaggle and can be accessed at Toxic Comment Classification Challenge.

gha_language: Jupyter Notebook


text:
# OniScan
A very simple TOR Hidden Service Web scanner & page scraper written in C#.
The only current function is PHPMyAdmin scanner, which tries to access any possible open PHPMyAdmin directories.

What's the goal of all this you might ask ?
This whole project is only a 'base' that can easily be extended. My main goal was to make C# work with TOR successfully.
I can imagine many other useful scanning features being added in the future.

Contact:

<EMAIL_ADDRESS><EMAIL_ADDRESS>
Projekt , Hodina PV 14.11 2017

repository: ondradus/OniScan

repo_name: ondradus/OniScan


text:
pio
===

PIo is short for Raspberry Pi GPIO. This C library allows the Raspberry Pi's GPIO pins to be accessed through a
C library.

## Features

* Simple API (5 public functions).
* Fast (writes bits directly to the GPIO registers).
* No external dependencies outside of the Linux C libraries.
* Set, clear, and read status from any valid GPIO pin.
* Allows GPIO pins on the GPIO connector to be referenced by position on the connector.
* Changes the mapping of the GPIO pins on the P1 connector to the Broadcom pins based on hardware revision.

## Usage

### Including the Library
* Download gpio.c, gpio.h, and register.h.
* Include gpio.h in files that need to access the API.

### Using the Library
* StatusCode initialize_gpio(); - Maps the GPIO memory and verifies that a Raspberry Pi with a known revision is
                                  running the library (run first).
* StatusCode set_gpio_pin(int pin_number, PinType pin_type); - Sets a given pin high.
* StatusCode clear_gpio_pin(int pin_number, PinType pin_type); - Clears a given pin.
* StatusCode get_gpio_pin(int pin_number, PinType pin_type, int* pin_value); - Gets the value of a given pin.
* StatusCode finalize_gpio(); - Unmaps the GPIO memory (always run once the library is no longer needed).

### Note:
* It is the responsibility of the user to make sure initialize_gpio() returns success before attempting
to use set_gpio_pin, clear_gpio_pin, or get_gpio_pin, or these functions will return a failure status to
avoid unexpected results.
* It is the responsibility of the user to make sure finalize_gpio() is called before the program exits. Failure
* to do so will leave the GPIO registers mapped in memory after the program exits.

## Data Type Description

* PinType - Specifies the type of connector that the pin numbers are referencing.
 * BROADCOM - The pin numbers in the Broadcom manual referenced by the Raspberry Pi's schematic.
 * P1CONNECTOR - The physical pin numbers on the Raspberry Pi's P1 connector.
* StatusCode - Specifies the outcome of calling an API function.
 * SUCCESS - The function returned successfully.
 * NOT_ROOT - The executable is not seteuid root, and the executable was not run as root (either one will work).
 * INVALID_CHIPSET - The hardware is unreadable or not recognized by the program.
 * CANNOT_MAP_MEMORY - The GPIO memory cannot be mapped for an unknown reason (sorry, can't do any better).
 * NO_INIT - The init function has not been completed successfully.
 * INVALID_PIN - The pin number is not a pin number supported by the current pin type.
 * REGISTER_FAILURE - There was an internal problem setting a register

## Questions/Bugs/Suggestions

If you have any questions, have found a bug, or have suggestions to offer, please contact me through GitHub.

## Future Features/Bug Fixes

* A program will be available to set, clear, and get gpio pins without the need to use the API calls within a
  program. This will allow any programming language to use the library by invoking a program as well as allow
  for command line use. The program will use the seteuid bit to allow any user to access GPIO without sudo.
* Any bugs that are reported will be fixed as soon as possible.
* There is not a set timeframe for future features. They will be added as needed.

## Regarding Root Access

In order to map the register memory, the library requires root access. Simply running the entire program as root
is a poor idea because it can introduce a severe security hole. Instead, the program should be owned by the root
user with the seteuid permission bit set. This allows anyone who runs the program to have the permissions of the
file's owner. The program will begin running as root. During this time, all of the program's tasks that require
root privleges (initialize_gpio() in the case of this library) should be run. Once these tasks are complete,
run the system call to change the effective user id to the actual user id (the user who ran the file). This allows
the remainder of the program to run as the non-root user, restricting any risk of security vulnerabilities to the
code that absolutely requires root. Although running as root avoids all of these steps, it is not recommended
practice.

repository: tnewman/pio

repo_name: tnewman/pio


text:
# Scaling your services with AWS

This repo is here to help you get started with AWS scaling using EC2 instances. This repo is accompanied by a set of blog posts designed to guide you through concepts and demo's to get you on your way to becoming a scaling wizard.

The blogs are posted on the Deakin Software and Technology Innovation Lab's [blog post site](http://dstil.ghost.io/), and the content is split over multiple blog posts (some of which are coming soon).

The first part of the blog post can be found [here](http://dstil.ghost.io/scaling-with-aws-1). (Alternatively it can be found [here](./Part1Resources/)).

## License

This repository is licensed under the `BSD 3-clause "New" or "Revised" License`. Please see the license file for details.

repository: stankowalczyk/scaling-with-aws

repo_name: stankowalczyk/scaling-with-aws


text:
##  Unit of Measure Definition (UM.CONTROL)

<PageHeader />

**Form Details**
[ Form Details ](UM-CONTROL-1/README.md)

**Purpose**
The UM.CONTROL procedure is used to define the valid unit of measure codes which may be used within the system. The unit of measure code is a two character abbreviation for a unit of measure. For example, the code "EA" might be used to denote the unit of measure "Each", or "FT" might be used for "Foot". When a unit of measure is requested in a data entry procedure such as [ PARTS.E ](../../../../../../../../../../rover/AP-OVERVIEW/AP-ENTRY/ACCT-CONTROL/ACCT-CONTROL-1/ar-e/PARTS-E) or [ PO.E ](../../../../../../../../../../rover/AP-OVERVIEW/AP-ENTRY/AP-E/AP-E-1/CURRENCY-CONTROL/PO-E) it is validated against the entries made in this procedure. If a match is not found the entry is rejected.

It is important that these entries be consistent over time. You should not
delete a unit of measure or change its meaning unless it is not currently
being referenced in the system.

**Frequency of Use**
These entries are usually entered when the system is first being setup since
they are required before some other procedures may be used. After the initial
setup it is used as required to add new codes.

**Prerequisites**
None.

<badge text= "Version 8.10.57" vertical="middle" />

<PageFooter />

repository: zumasys/docs

repo_name: zumasys/docs


text:
<!---
This is an autogenerated file!

Please do not edit this file directly, but instead make changes to the
sigs.yaml file in the project root.

To understand how this file is generated, see https://git.k8s.io/community/generator/README.md
--->
# Structured Logging Working Group

Modernize logging in Kubernetes core components, allowing users to efficiently consume, process, store and analyse information stored in logs.

The [charter](charter.md) defines the scope and governance of the Structured Logging Working Group.

## Stakeholder SIGs
* [SIG API Machinery](/sig-api-machinery)
* [SIG Architecture](/sig-architecture)
* [SIG Cloud Provider](/sig-cloud-provider)
* [SIG Instrumentation](/sig-instrumentation)
* [SIG Network](/sig-network)
* [SIG Node](/sig-node)
* [SIG Scheduling](/sig-scheduling)
* [SIG Storage](/sig-storage)

## Meetings
*Joining the [mailing list](https://groups.google.com/forum/#!forum/kubernetes-wg-structured-logging) for the group will typically add invites for the following meetings to your calendar.*
* Regular Meeting: [Thursdays at 15:30 London-UK](https://zoom.us/j/96716142646?pwd=VmgrN29sbmhDREp3R0NtZlpGSlZ4Zz09) (biweekly). [Convert to your timezone](http://www.thetimezoneconverter.com/?t=15:30&tz=London-UK).
  * [Meeting notes and Agenda](https://docs.google.com/document/d/1R9bZ34L9vR1ftH0dFeOp-j50lLh5ijKVwwXJ3LDrY4I/edit?usp=sharing).
  * [Meeting recordings](https://www.youtube.com/playlist?list=PL69nYSiGNLP2GY3so1z2Cnkvkt5A_x1Aw).

## Organizers

* Patrick Ohly (**[@pohly](https://github.com/pohly)**), Intel
* Marek Siarkowicz (**[@serathius](https://github.com/serathius)**), Google

## Contact
- Slack: [#wg-structured-logging](https://kubernetes.slack.com/messages/wg-structured-logging)
- [Mailing list](https://groups.google.com/forum/#!forum/kubernetes-wg-structured-logging)
- [Open Community Issues/PRs](https://github.com/kubernetes/community/labels/wg%2Fstructured-logging)
- Steering Committee Liaison: Nabarun Pal (**[@palnabarun](https://github.com/palnabarun)**)
<!-- BEGIN CUSTOM CONTENT -->

<!-- END CUSTOM CONTENT -->

repository: kubernetes/community

repo_name: kubernetes/community


text:
---
layout:    post
title:     Hello World!
date:      2015-08-27 18:58:12
summary:   Hi there, here's the first post on my blog. This is where I'm gonna share my passions, knowledge, tips and tricks.
---

{% highlight c++%}
#include <iostream>
using namespace std;
int main() {
	cout << "Hello world\n";
	return 0;
}
{% endhighlight %}

So here I am, writing the first post on this blog. I named it 'Not just another blog' because I like to think I'm different and unique.

First, I would like to thank [Alex Palcuie](http://blog.palcu.ro/) for sharing me the informations I needed to start this website, [Jekyll](http://jekyllrb.com/) for such an awesome, free and open-source software and [John Otlander](http://johnotander.com/) for this pretty minimalistic theme.

My name is [Cosmin](/about) and I'm from a nice small town called Beclean. I like to code, swim, teach and solve problems. I'm fluent in C++ and starter in Java, Python and JavaScript. What language do you speak? I hit the gym three times a week following [Greg O'Gallagher's](https://instagram.com/gregogallagher/) advices on nutrition and workout plans. I want to start Snowboarding very very bad, but I haven't had the chance.
I'll start the Faculty of Mathematics and Computer Science at Babeş-Bolyai University in Cluj, starting my career path as a software engineer.

I'm not really sure yet what I'm going to write about here. I think it will be stuff I make, things that entertain me or just my random thoughts. I had the idea to start blogging a long time ago, and I'm very excited I see this starting point.

> Today is a new beginning

And I'm gonna stop here; see you in the near future, dear reader!


text:
# Jupyter Notebook Setup

These instructions assume you already have Jupyter Notebooks installed. If you don't then you can consider the resources at https://jupyter.org/install.

## 1. Installing Packages Under Jupyter

To install the required packages, run the following...

```python
import sys
!{sys.executable} -m pip install fightchurn
```

[If you are wondering why that command, I followed these instructions](https://jakevdp.github.io/blog/2017/12/05/installing-python-packages-from-jupyter/).

You should see a bunch of outputs about collecting and installing packages. Yours might not look exactly like this, but something along these lines...

![Install package with pip](note1_env_start.png)

After several minutes (depending on your sytem and internet speed) you should see this at the end of the install...

![Successful package install](./note2_env_done.png)

(You might not see the warning about upgrading pip but if you do don't worry about it.)

## 2 Import the run_churn_listing_module

Next, make these imports to get ready to run the code...

```python
from fightchurn import run_churn_listing
from fightchurn.run_churn_listing import run_listing
```

## 2  Set the churn environment variables

Now you need to set a few enviroment variables. These are:

1. The database name : 'churn' in the example below
2. The username for the database
3. The password for the database
4. A local folder where  outputs can be written....

```python
run_churn_listing.set_churn_environment('churn','user','password','/path/to/my_churn_output_folder')
```

This will print out a confirmation line as follows:

```
Setting Environment Variables user=carl for db=churn
```

---

## 3 Run the data simulation

Next, you need to write some data to the database in order to run the code against - no data is provided with the code distribution. Use the following command:

```python
run_churn_listing.run_standard_simulation(init_customers=10000)
```

The example is for a standard simulation of 10,000 customers. If you want to speed things up you can run it for 1000 customers and things will still work okay - the results will just be a bit more noisy and random.

You will see output as follows...

![Setup environment and Run Simulation](note3_sim.png)

This will continue for a while - maybe 15-30 minutes if you ran the full 10,000 customer simulation.

## 4 Run code listings from the book

### 4.1 Running One Listing

Now you are ready to run some code from the book! To do that you use the `run_listing` function that you previously imported. For examle, the following is chapter 2, listing 2:

```python
run_listing(2,2)
```

You should see output like this:

![Run Listing](note4_churn.png)

Explaining what you ares seeing there is beyond the scope of this README, thats what the book is about! But if you have gotten this far, then you have completed all the setup and you are ready to follow along with the book (or videos, however you are learning the code...)

#### 4.2 Running multiple listings

In some parts of the book you might want to run more than one listing at once. To do this,
pass as a list for the listing argument. For example, to run all four chapter 2 churn
calculation listings try:

```python
run_churn_listing.run_listing(2,[1,2,3,4])
```

#### 4.3 Running listing versions

Later in the book, some of the listings have multiple versions with different arguments. The
`run_listing` function also takes a version argument. For example, to run a query and plot the
results of the events per day for the first event created by the simulation, try the following:

```python
run_churn_listing.run_listing(chapter=3,listing=[9,10],version=1)
```

That command should save a plot like this to your output directory:

![like_per_day](/Users/carl/Documents/churn/fight-churn/readme_files/like_per_day.png)

You can also run multiple versions at once:

```python
run_churn_listing.run_listing(chapter=3,listing=[9,10],version=[2,3])
```

For more information about what the code listings do, see the book Fighting Churn With Data.

------

repository: shadrack-oo/fight-churn

repo_name: shadrack-oo/fight-churn


text:
# Website
Please switch to [gh-pages](https://github.com/hungvt13/typography.css/tree/gh-pages) branch to see the website structure and implementation

# typography.css [![GitHub release](https://img.shields.io/github/release-pre/hungvt13/typography.css.svg)](https://github.com/hungvt13/typography.css) [![npm version](https://badge.fury.io/js/ht-typography.css.svg)](https://badge.fury.io/js/ht-typography.css) ![](https://img.shields.io/npm/l/express.svg)

_Plug and use preset fonts CSS_

[Demo](https://hungvt13.github.io/typography.css/)

`typography.css` is a css that change your default font using more beautiful preset. Great to use in projects that emphasis on typography.

# Installation

Install via npm:

```bash
$ npm i ht-typography.css --save
```

## Usage

To use typography.css in your website, simply drop the stylesheet into your document's `<head>`, and add the class `animated` to an element, along with any of the animation names. That's it! You've got a CSS animated element. Super!

All you need is to add the stylesheet into your html `<head>` and add the preset to the `<body>` or `<div>` tag.

```html
<head>
  <link rel="stylesheet" href="typography.css">
</head>
```

### Classes

To animate an element, add the class `animated` to an element. You can include the class `infinite` for an infinite loop. Finally you need to add one of the following classes to the element:

| Class Name Presets|  Class Headers     | Class Paragraph      |
| ----------------- | ------------------ | -------------------- |
| `general`         | `general_header`   | `general_paragraph`  |
| `high-end`        | `high-end_header`  | `high-end_paragraph` |
| `modern`          | `modern_header`    | `modern_paragraph`   |
| `start-up`        | `start-up_header`  | `start-up_paragraph` |
| `elegant`         | `elegant_header`   | `elegant_paragraph`  |
| `attention`       | `attention_header` | `attention_paragraph`|
| `medieval`        | `medieval_header`  | `medieval_paragraph` |
| `art`             | `art_header`       | `art_paragraph`      |

Example Preset:

```html
<div class="elegant">
  <h1>Header</h1>
  <p>paragraph here</p<
</div>
```
Example Individual Element:

```html
<div>
  <h1 class="art_header">Header</h1>
  <p class="modern_paragraph">paragraph here</p<
</div>
```

## License

Typography.css is licensed under the MIT license. (http://opensource.org/licenses/MIT)

gha_language: CSS


text:
Slit-scan Photography
=====================

# Install

```
pip install slitscan
```

# Usage

```
slitscan -i movie.mp4
```

repository: markjarzynski/slitscan

repo_name: markjarzynski/slitscan


text:
# EvilNet
Small serialization and network engine for Java.

The goal of this engine is to show how to do serialization for network applications properly in Java.

The engine can handle everything between taking objects and serialize them and send them on one end and
receiving them as a byte-array on the other end and then deserialize them into objects with the same values.

The engine makes use of generic types so a user can send any type of object into the engine as long as the
object implements the Serializable-interface.

EvilNet can make use of all network traffic protocols, including multicast sockets. Messages are sent based on
a tick rate that is defined when EvilNet is initialized.

Download this engine as a zip and put it into your project. Depending on where you put the files you may have
to chanage the package-names for EvilNet. After that, check the file EvilNet.java to get an idea of how to
make use of the engine in your project.

repository: Evixy/EvilNet

repo_name: Evixy/EvilNet


text:
# CS467 Cetus-1 AST

### Automatic Test Instructions
1. To run and view the abstract syntax tree, you need to enter the AST folder. Make sure that the make.sh bash file is executable. If it is not run
```
chmod +x make.sh
```
Then you can run the bash script with
```
./make.sh
```
1. If you would like to run the tests individually you can run
```
make test(x)
```
, where x = 1, 2, 3, or 4. It only tests the valid test files, or else the type checker would just exit with an error and not produce a tree

### Manual Test Instructions

1. If you want to manually input Csimple code you can run
```
./csimple
```

and it will ask for input. It will continue scanning unless you enter invalid Csimple code, then it will output an error.  It will only scan/parse/type check since  it does not output to a file.

---

* If you would like to output an abstract syntax tree in a pdf, you need to have the source code in a file. Here are the steps you need need to run

1.
```
make csimple
```

2.
```
dos2unix [source code filename]
```

3.
```
./csimple < [source code filename] >> testoutput.out
```
 * Note: You can stop here if you just want to view the parser/scanner output

4.
```
./csimple <  [source code filename] >> testoutput.dot
```

5.
```
dot -Tps testoutput.dot > testoutput.ps
```

6.
```
Ps2pdf testoutput.ps testoutput.pdf
```

repository: iwatakeshi/Cetus-Compiler

repo_name: iwatakeshi/Cetus-Compiler


text:
---
title: "Fractal Trees - L-System"
redirect_from: CodingChallenges/16-lsystem.html
video_number: 16
date: 2016-05-31
video_id: E1B4UoSQMFw
repository: CC_016_LSystem
web_editor: QmTx-Y_UP

links:
  - title: "Algorithmic Botany"
    url: "http://algorithmicbotany.org/"

contributions:
  - title: "L-SystemCreator"
    author:
      name: "Anurag Hazra"
      url: "https://anuraghazra.github.io/"
    url: "https://anuraghazra.github.io/LSystemCreator/"
    source: "https://github.com/anuraghazra/LSystemCreator"
  - title: "Trees as Stochastic L-Systems"
    author:
      name: "Ameya Daigavane"
      url: "https://github.com/ameya98"
    url: "https://ameya98.github.io/WebPPL/generative_art/"
    source: "https://github.com/ameya98/WebPPL/tree/master/generative_art"
---

In this third installment of my series on algorithmic botany, I discuss L-systems and how they can be used to generate tree and other fractal patterns in p5.js.