text:
[![Build Status](https://travis-ci.org/benbria/browserify-transform-tools.svg)](https://travis-ci.org/benbria/browserify-transform-tools)
[![Coverage Status](https://coveralls.io/repos/benbria/browserify-transform-tools/badge.svg)](https://coveralls.io/r/benbria/browserify-transform-tools)
[![Dependency Status](https://david-dm.org/benbria/browserify-transform-tools.svg)](https://david-dm.org/benbria/browserify-transform-tools)
[![devDependency Status](https://david-dm.org/benbria/browserify-transform-tools/dev-status.svg)](https://david-dm.org/benbria/browserify-transform-tools#info=devDependencies)

[![NPM](https://nodei.co/npm/browserify-transform-tools.png?downloads=true&downloadRank=true&stars=true)](https://nodei.co/npm/browserify-transform-tools/)

This package contains tools for helping you write [transforms](https://github.com/substack/node-browserify#browserifytransform) for [browserify](https://github.com/substack/node-browserify).

Many different transforms perform certain basic functionality, such as turning the contents of a stream into a string, or loading configuration from package.json.  This package contains helper methods to perform these common tasks, so you don't have to write them over and over again:

* `makeStringTransform()` creates a transform which consumes and returns a string, instead of using a stream.
* `makeFalafelTransform()` parses a JS file using [falafel](https://github.com/substack/node-falafel) and allows you to modify the code.
* `makeRequireTransform()` passes you the contents of each `require()` call in each script, and allows you to rewrite the require statement.
* All of the above will automatically search for transform configuration in package.json and pass it to you if available, but if you have a more complicated use case than the `make*Transform()` functions will support, then `loadTransformConfig()` will load configuration for you.
* `runTransform()` can be used to unit test your shiny new transform.

Installation
============

Install with `npm install --save browserify-transform-tools`.

Creating a String Transform
===========================
Browserify transforms work on streams.  This is all well and good, until you want to call a library like "falafel" which doesn't work with streams.  (If you're using falafel specifically, see below for `makeFalafelTransform`.)

Suppose you are writing a transform called "unbluify" which replaces all occurances of "blue" with a color loaded from a configuration:

```JavaScript
var options = {excludeExtensions: [".json"]};
module.exports = transformTools.makeStringTransform("unbluify", options,
    function (content, transformOptions, done) {
        var file = transformOptions.file;
        if(!transformOptions.config) {
            return done(new Error("Could not find unbluify configuration."));
        }

        done(null, content.replace(/blue/g, transformOptions.config.newColor));
    });
```

Notice that the color we replace "blue" with gets loaded from configuration.  The configuration
can be set in a variety of ways.  A simple example is to set it directly in package.json:

```JavaScript
{
    "name": "myProject",
    "version": "1.0.0",
    ...
    "unbluify": {"newColor": "red"}
}
```

See the section on "Loading Configuration" below for details on where configuration can be loaded from.

Parameters for `makeStringTransform()`:

* `transformFn(contents, transformOptions, done)` - Function which is called to
  do the transform.  `contents` are the contents of the file.  `done(err, transformed)` is
  a callback which must be called, passing the a string with the transformed contents of the
  file.  `transformOptions` consists of:

  * `transformOptions.file` is the name of the file (as would be passed to a normal browserify transform.)

  * `transformOptions.config` is the configuration for your transform, loaded either from
    browserify or from package.json.

  * `transformOptions.configData` is the configuration data for the transform (see
  `loadTransformConfig` below for details on where this comes from.)

* `options.excludeExtensions` - A list of extensions which will not be processed.  e.g.
  "['.coffee', '.jade']"

* `options.includeExtensions` - A list of extensions to process.  If this options is not
  specified, then all extensions will be processed.  If this option is specified, then
  any file with an extension not in this list will skipped.

* `options.jsFilesOnly` - If set true, then your transform will only run on "javascript" files.
  This is handy for Falafel and Require transforms, defined below.  This is equivalent to
  passing
  `includeExtensions: [".js", ".coffee", ".coffee.md", ".litcoffee", "._js", "._coffee", ".jsx", ".es", ".es6"]`.

Creating a Falafel Transform
============================
Many transforms are based on [falafel](https://github.com/substack/node-falafel). browserify-transform-tools provides an easy way to define such transforms.  Here is an example which wraps all array expressions in a call to `fn()`:

```JavaScript
var options = {};
// Wraps all array expressions in a call to fn().  e.g. '[1,2,3]' becomes 'fn([1,2,3])'.
module.exports = transformTools.makeFalafelTransform("array-fnify", options,
    function (node, transformOptions, done) {
        if (node.type === 'ArrayExpression') {
            node.update('fn(' + node.source() + ')');
        }
        done();
    });
```

`makeFalafelTransform()` will be called once for every node in your JS file.  You can update the node.  Be sure to pass errors back via `done(err)`, and call `done()` when complete.

Options passed to `makeFalafelTransform()` are the same as for `makeStringTransform()`, as are the transformOptions passed to the transform function.  You can additionally pass a `options.falafelOptions` to `makeFalafelTransform` - this object will be passed as an options object directly to falafel.

Creating a Require Transform
============================

Many transforms are focused on transforming `require()` calls.  browserify-transform-tools has a solution for this:

```JavaScript
transform = transformTools.makeRequireTransform("requireTransform",
    {evaluateArguments: true},
    function(args, opts, cb) {
        if (args[0] === "foo") {
            return cb(null, "require('bar')");
        } else {
            return cb();
        }
    });
```

This will take all calls to `require("foo")` and transform them to `require('bar')`.  Note that makeRequireTransform can parse many simple expressions, so the above would succesfully parse `require("f" + "oo")`, for example.  Any expression involving core JavaScript, `__filename`, `__dirname`, `path`, and `join` (where join is an alias for `path.join`) can be parsed.  Setting the `evaluateArguments` option to false will disable this behavior, in which case the source code for everything inside the ()s will be returned.

Note that `makeRequireTransform` expects your function to return the complete `require(...)` call.  This makes it possible to write require transforms which will, for example, inline resources.

Again, all other options you can pass to `makeStringTransform` are valid here, too.

Creating a Function Transform
============================

These transforms are focused on transforming arbitrary function calls:

```JavaScript
transform = transformTools.makeRequireTransform("requireTransform",
    {evaluateArguments: true, functionNames: ["foobar"]},
    function(functionParams, opts, cb) {
        if (functionParams.args[0].value === "foo") {
            return cb(null, functionParams.name + "('bar')");
        } else {
            return cb();
        }
    });
```

This will take all calls to `foobar("foo")` and transform them to `foobar('bar')`.  Note that makeFunctionTransform can parse many simple expressions, so the above would succesfully parse `foobar("f" + "oo")`, for example.  Any expression involving core JavaScript, `__filename`, `__dirname`, `path`, and `join` (where join is an alias for `path.join`) can be parsed.  Setting the `evaluateArguments` option to false will disable this behavior, in which case the source code for everything inside the ()s will be returned.

Note that `makeFunctionTransform` expects your function to return the complete `[functionName](...)` call.  This makes it possible to write function transforms which will, for example, inline resources.

The option `functionNames` can either be a string or an array of strings. If no functionName is provided `makeFunctionTransform` fallbacks to `require()` calls.

The `functionParams` object which is passed to the given transform function has 2 attributes. The first one is `name` which is the function name The second one is `args` and is an ordered array of the function args. Each entry consists of `value` and `type`. Type can be one of these values: `Literal, Identifier, FunctionExpression, ObjectExpression, ArrayExpression`.

Again, all other options you can pass to `makeStringTransform` are valid here, too.

Loading Configuration
=====================

All `make*Transform()` functions will automatically load configuration for your transform and make it available via `transformOptions.config` (and through the more detailed `transformOptions.configData`.)  Functions are also provided for reading configuration if you are not using one of the `make*Transform()` functions.

Transform configuration can be loaded from a project's package.json file, from a js or coffee file specified in package.json, or programatically.  For details, see [the transform configuration documentation](https://github.com/benbria/browserify-transform-tools/wiki/Transform-Configuration).

Running a Transform
===================
If you want to unit test your transform, then `runTransform()` is for you:

```JavaScript
var myTransform = transformTools.makeFalafelTransform(...);
var dummyJsFile = path.resolve(__dirname, "../testFixtures/testWithConfig/dummy.js");
var content = "console.log('Hello World!');";
transformTools.runTransform(myTransform, dummyJsFile, {content: content},
    function(err, transformed) {
        // Verify transformed is what we expect...
    }
);
```

Thanks
======
Some of this was heavily inspired by:

* [ForbesLindesay](https://github.com/ForbesLindesay)'s [rfileify](https://github.com/ForbesLindesay/rfileify)
* [thlorenz](https://github.com/thlorenz)'s [browserify-shim](https://github.com/thlorenz/browserify-shim)

repository: AdoraNwodo/ECommerce-Sailsjs-API

repo_name: AdoraNwodo/ECommerce-Sailsjs-API


text:
---
layout: project
type: project
image: images/database.jpg
title: Bank Database Application
permalink: projects/bank-database-application
# All dates must be YYYY-MM-DD format!
date: 2019-04-14
labels:
  - C++
summary: For my ICS 212 class, I was assigned a semester long project called the Bank Database Application that stores the account number, name, and address of the user into a record.
---

## Introduction

For my ICS 212 class I was assigned a semester long project called the Bank Database Application. This project displayed a menu
that gave different options to the user, where the user could provide an account number, name, and address to create a new record and store it into the database. From there, the user could add more records, delete them, change existing records, or search for a record.

The first iteration of the program was written in C code and later, was revised to include elements of C++. This project was a real
challenge because C and C++ have very basic elements and don't include many features that the later Java has. It was also difficult because I had to trace pointers which can be confusing and very time consuming if not done right.

## What I learned

This project taught me skills in tracing and helped me better understand the concept of pointers. It also strengthened my skills in problem solving and designing algorithms for programs. ICS 212 was the most time consuming class for me at the time. I actually had to take the class twice because I wasn't prepared for the time commitment the first time around. Nonetheless, that class and the Bank Database project were both valuable for my learning and helped me grow as a programmer. Now, I'm more confident in writing code and ready for what challenges I'll face in the future.

[Here's the repository for the Bank Database files](https://github.com/kasons/ICS212-PROJECT2)

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# HHUIKit

[![CI Status](http://img.shields.io/travis/MRCaoHH/HHUIKit.svg?style=flat)](https://travis-ci.org/MRCaoHH/HHUIKit)
[![Version](https://img.shields.io/cocoapods/v/HHUIKit.svg?style=flat)](http://cocoapods.org/pods/HHUIKit)
[![License](https://img.shields.io/cocoapods/l/HHUIKit.svg?style=flat)](http://cocoapods.org/pods/HHUIKit)
[![Platform](https://img.shields.io/cocoapods/p/HHUIKit.svg?style=flat)](http://cocoapods.org/pods/HHUIKit)

## Example

To run the example project, clone the repo, and run `pod install` from the Example directory first.

## Requirements

## Installation

HHUIKit is available through [CocoaPods](http://cocoapods.org). To install
it, simply add the following line to your Podfile:

```ruby
pod 'HHUIKit'
```

## Author

MRCaoHH<EMAIL_ADDRESS>
## License

HHUIKit is available under the MIT license. See the LICENSE file for more info.

repository: MRCaoHH/HHUIKit

repo_name: MRCaoHH/HHUIKit


text:
# SurRender software examples

The SurRender software is a powerful image renderer developed by the Image Processing Advanced Studies team of Airbus Defence & Space.
It is specially designed for space applications such as vision-based navigation (planetary approach and landing, in orbit rendezvous, etc.).
It uses raytracing (CPU) or openGL (GPU) and it is highly optimized for space simulations (sparse scenes, reflections and shadows, large distance dynamics, huge datasets).
Users can input various data at standard formats (Digital Elevation Models, images, meshes), and configure models for various properties such as materials and sensors (shutter type, noises, integration time, etc.). SurRender simulations aim at physical representativeness as needed for the development and validation of  computer vision algorithms.
This GitHub project gathers examples of scenarios the can be simulated by the SurRender software with the Python API.

## Getting Started
The SurRender client API may be dowloaded from GitHub [surrender_client project](https://github.com/SurRenderSoftware/surrender_client_API).
A selection of tests is provided in this project. They are coded in Python. They range from installation and basic tests to advanced simulations of 3D objects (meshes and DEMs):

* script_00_installation_control.py
* script_01_rendering_a_sphere.py
* script_02_simple_earth_sun_camera_system.py
* script_03_summer_solstice.py
* script_04_raytracing_precision.py
* script_05_psf.py
* script_06_tycho_background.py
* script_07_stellar_background.py
* script_08_itokawa_mesh.py
* script_09_ceres_landing.py
* script_10_itokawa_SPICE.py

## Prerequisite
A standard Python3 installation is required, e.g. Anaconda.
The server is delivered with all the needed dependencies.

## Running the tests
Start the server in a terminal by running:
```
./start_server.sh
```

Run tests in Python by executing for exemple:
```bash
python3 script_00_installation_control.py
```

## Contributing
Users are invited to share their scenarios in a format similar to the available examples such as `script_08_itokawa_mesh.py` and  `script_09_ceres_landing.py`
Self-sufficient explanation should be provided in order to retrieve the needed data.

## License
This project is licensed under the Apache License Version 2.0 of January 2004. See the LICENSE file for details.

(C) 2019 Airbus copyright all rights reserved

## References
Information about the software is available at this [website](https://www.airbus.com/SurRenderSoftware.html) and in this [article](https://arxiv.org/abs/1810.01423 )

gha_language: Python


text:
# Auto Generated Blog aggregator
## [#156 Bash, Apple and EJB, TomEE, Geronimo and Jakarta EE](https://www.tomitribe.com/blog/156-bash-apple-and-ejb-tomee-geronimo-and-jakarta-ee/)
  - Author: Tomitribe
  - Tue, 14 Sep 2021 14:07:51 +0000
## [Using Tomcat’s `tomcat-users.xml` with Jakarta Security in TomEE](https://www.tomitribe.com/blog/using-tomcats-tomcat-users-xml-with-jakarta-security-in-tomee/)
  - Author: Tomitribe
  - Tue, 31 Aug 2021 15:09:02 +0000
## [Understanding Jakarta Security with TomEE](https://www.tomitribe.com/blog/understanding-jakarta-security-with-tomee/)
  - Author: Tomitribe
  - Thu, 15 Jul 2021 17:13:27 +0000
## [Apache TomEE Jakarta EE certified after 10 years](https://www.tomitribe.com/blog/apache-tomee-jakarta-ee-certified-after-10-years/)
  - Author: Tomitribe
  - Tue, 25 May 2021 10:53:05 +0000
## [Keeping Brazil’s Medical Industry Safe with MicroProfile | JakartaOne Livestream 2020](https://www.tomitribe.com/blog/keeping-brazils-medical-industry-safe-with-microprofile-jakartaone-livestream-2020/)
  - Author: Tomitribe
  - Thu, 25 Feb 2021 15:12:45 +0000
## [Pavimentando el Camino con Jakarta EE 9 and Apache TomEE](https://www.tomitribe.com/blog/pavimentando-el-camino-con-jakarta-ee-9-and-apache-tomee/)
  - Author: Tomitribe
  - Fri, 18 Dec 2020 10:05:32 +0000
## [Introducing TCK.work](https://www.tomitribe.com/blog/introducing-tck-work/)
  - Author: Tomitribe
  - Wed, 02 Dec 2020 18:12:42 +0000
## [JakartaONE Español 2020: De Comunidad Para Comunidad!](https://www.tomitribe.com/blog/jakartaone-espanol-2020-de-comunidad-para-comunidad/)
  - Author: Tomitribe
  - Wed, 04 Nov 2020 17:15:27 +0000
## [JakartaONE Brazil 2020: Como alavancar microservices com TomEE e MicroProfile para ajudar a indústria médica no Brasil.](https://www.tomitribe.com/blog/como-alavancar-microservices-com-tomee-e-microprofile-para-ajudar-a-industria-medica-no-brasil/)
  - Author: Tomitribe
  - Thu, 15 Oct 2020 10:51:48 +0000
## [DevNexus 2020 Video Interview with Emily Jiang & David Blevins](https://www.tomitribe.com/blog/devnexus-interview-with-emily-jiang-david-blevins/)
  - Author: Tomitribe
  - Tue, 30 Jun 2020 14:02:53 +0000

repository: cesarhernandezgt/blog-buffet

branch_name: refs/heads/main

gha_language: Shell

repo_name: cesarhernandezgt/blog-buffet


text:
---
layout: post
categories: blog
title: LSST Administrativa
use_math: true
---

* Table of Contents
{:toc}

## LSST Adminstrativa

To change their password:
Login to https://project.lsst.org/phpmyadmin
Under General Settings, locate link “Change Password”
Set new complex password:
        i) English uppercase characters (A - Z)
         ii) English lowercase characters (a - z)
         iii) Base 10 digits (0 - 9)
         iv) Non-alphanumeric (for example: !, $, #, or %)

The phpmyadmin is exposed to the outside world. It is necessary to have a secure password.

Because so few users have access, resources were never put forth to connect to LDAP. This account is independent of all other accounts.

Process to Add a New Contact (don’t have a formal page but do have rough process that needs to be polished):
Go to https://project.lsst.org/LSSTContacts/MemberListPage1.php
There is a “login” link just above text LSST Contacts DB.
Click the link to access login page.
Use creds provided.
You will see a new set of options but the formatting is off.
Look for “Add New Contact”
Fill in information
Once entry has been made you have the option to go to Science Tab (first of the two) and check off which SC person belongs to.
Every night at 9pm, scripts will add the contact to the particular SC mailman list and scicoll mailman list.

For altering existing contacts,
Go to Individual Directory
Do a search
Click on the particular contact
In “right window”, if necessary scroll down, click Update Info
Go to the Science Tab (first of the two) and check off which SC person belongs to and uncheck the others
Every night at 9pm, scripts will add the contact to the particular SC mailman list and scicoll mailman list.

gha_language: HTML

gha_license_id: MIT


text:
# node-calculator · [![Build Status](https://travis-ci.com/ameerthehacker/node-calculator.svg?branch=master)](https://travis-ci.com/ameerthehacker/node-calculator)
A simple app for automated tests using jest

### How to run the app locally
To run locally you need to be sure that the dependencies are installed:
```
$ npm install
```
To run:
```
$ npm start
```

### How to test the app

```
$ npm test
```

### How to run code coverage

```
$ npm run test-coverage
```
Note the duplicate --.
The first separates the parameters passed to the npm command itself and the following are passed to the test script.

repository: ameerthehacker/node-calculator

gha_language: JavaScript

repo_name: ameerthehacker/node-calculator


text:
# Webpack and React Together

## Resources

 - [babel-loader: Webpack plugin for Babel](https://github.com/babel/babel-loader)
 - [Setting Up Webpack for React and Hot Module Replacement](https://robots.thoughtbot.com/setting-up-webpack-for-react-and-hot-module-replacement)
 - [React - Module parse failed: You may need an appropriate loader to handle this file type](https://github.com/babel/babel-loader/issues/173)
 - [WebPack-React-Starter](https://github.com/JakeGinnivan/WebPack-React-Starter)

repository: tugberkugurlu/ReactJsSamples

repo_name: tugberkugurlu/ReactJsSamples


text:
This example showcases:

- Typesafe routing
- Enter/Exit animation of views
- Custom select/popup components
- How to do ajax without concurrency issues

The example is deployed [here](http://alexgalays.github.io/kaiju/example/public/#/blue/33/green)

Installation:

```
git clone https://github.com/AlexGalays/kaiju.git
cd example
npm install
npm run watch
open public/index.html
```

repository: joguedz/kaiju

repo_name: joguedz/kaiju


text:
# Ionic 4 Build App Example – IOS, Android, Web

This project accompanies the [Jameson Saunders](https://jamesonsaunders.com) YouTube video [Ionic Build App Example – IOS, Android, Web – (Mac Tutorial)](https://youtu.be/B_seja5eHt8).

There's also a separate windows tutorial as well: [Ionic Build App Example – Android – (Windows Tutorial)](https://youtu.be/c7HmwiTtYPE).

[![Ionic Build App Example – IOS, Android, Web – (Mac Tutorial)](https://img.youtube.com/vi/B_seja5eHt8/maxresdefault.jpg)](https://youtu.be/B_seja5eHt8)

[![Ionic Build App Example – Android – (Windows Tutorial)](https://img.youtube.com/vi/c7HmwiTtYPE/maxresdefault.jpg)](https://youtu.be/c7HmwiTtYPE)

A minimal example used in the video tutorial for building Ionic app building for IOS, Android, and Web.

If you haven't already, check out the [Jameson Saunders YouTube Channel](https://youtube.com/c/JamesonSaunders) for web & mobile development videos.

## Installation

Download or clone this project, then run `npm i` from the project directory to install its dependencies. Not familiar with NPM? Check out my [NPM Tutorial](https://www.youtube.com/watch?v=mzs-N5hXGuQ).

## Development server

Run `ionic serve -c` for a dev server. Navigate to `http://localhost:8100/`. The app will automatically reload if you change any of the source files.

## Further help

To get more help on the Ionic CLI use `ionic help` or go check out the [Official Ionic Guide](https://ionicframework.com/docs/building/starting).

repository: jamesonsaunders/Ionic-Build-App-Example

gha_language: TypeScript

repo_name: jamesonsaunders/Ionic-Build-App-Example


text:
# Salesforce Apex

[![CircleCI](https://circleci.com/gh/forcedotcom/salesforcedx-apex.svg?style=svg&circle-token=5869ea795e44e1b737f2f2a86fd51cdc2ac08629)](https://circleci.com/gh/forcedotcom/salesforcedx-apex)
![npm (scoped)](https://img.shields.io/npm/v/@salesforce/plugin-apex)
[![License](https://img.shields.io/badge/License-BSD%203--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
[![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)

## Introduction
Typescript library and oclif plugin to support the Salesforce Apex commands.

This repository provides:
* [@salesforce/plugin-apex](https://www.npmjs.com/package/@salesforce/plugin-apex) oclif plugin that supports all Apex related commands. It is bundled with the [salesforcedx plugin](https://www.npmjs.com/package/salesforcedx)
* [@salesforce/apex-node](https://www.npmjs.com/package/@salesforce/apex-node) Typescript library to support the Apex plugin and the [Salesforce Extensions for VS Code](https://github.com/forcedotcom/salesforcedx-vscode/)

Note: This library is in beta and has been released early so we can collect feedback. It may contain bugs, undergo major changes, or be discontinued.

<br/>

## Getting Started

If you're interested in contributing, take a look at the [CONTRIBUTING](./CONTRIBUTING.md) guide.

If you're interested in building the plugin and library locally, take a look at the [Developing](./contributing/developing.md) doc.

You can find more information about commands that the plugin provides in the [Commands](./contributing/commands.md) doc.

repository: YodaDaCoda/salesforcedx-apex

repo_name: YodaDaCoda/salesforcedx-apex


text:
# Project Structure / Contributing

Check open issues for a list of features/bugs that we would like to see
fixed/implemented.

## EditorConfig

To make sure we all use the same basic settings (indent, EOL, EOF) please
install [EditorConfig](http://editorconfig.org/#download). It will make code
review/merge easier.

## New Features / Bugs

The easiest way to add new features and fix bugs is to create a test file with
mixed input and use the [rocambole-visualize](http://piuccio.github.io/rocambole-visualize/)
or the [esprima parser demo](http://esprima.org/demo/parse.html) to visualize
the syntax tree and implement each step separately.

We augment the AST with
[rocambole](https://github.com/millermedeiros/rocambole), so every `node` have
[extra
properties](https://github.com/millermedeiros/rocambole#extra-properties) that
can be used to traverse the AST (similar to the DOM).

The whole process is very similar to working with the DOM. Don't feel
intimidated by *complex names* like `ConditionalExpressionConsequent`, use the
[esprima parser demo](http://esprima.org/demo/parse.html) and/or
[rocambole-visualize](http://piuccio.github.io/rocambole-visualize/) as reference
and you should be good to go.

We rely on some external libraries to add/remove/find tokens:

 - [rocambole-token](https://github.com/millermedeiros/rocambole-token)
 - [rocambole-whitespace](https://github.com/millermedeiros/rocambole-whitespace)
 - [rocambole-linebreak](https://github.com/millermedeiros/rocambole-linebreak)

### Recursion

The recursion starts from the *leaf nodes* and moves till it reaches the
`Program` root. It works this way because child nodes usually affects the
parent nodes structure (specially line breaks), that gives the option for the
parent node to override the child node behavior if needed.

### Adding/Removing line breaks and white spaces

The `format` method of each object exposed on `lib/hooks.js` is called once for
each matching `node`. The `format` method is responsible for adding/removing
line breaks and white spaces based on the node structure and config options.

### Indentation

We do the indentation after the whole process; that is necessary since the
parent nodes affects the indentation of the child nodes (line breaks might be
added or removed during the process).

The core logic is handled by `lib/indent.js`, but most nodes actually require
specific rules to detect the *indent edges*, so most `lib/hooks` also implement
a method `getIndentEdges` that can return:

 - *falsy* value: means the node should **not** be indented;
 - single `IndentEdge` object: indent in between `startToken` and `endToken`;
 - array containing multiple `IndentEdge` objects and/or *falsy* values: indent
   inside any `IndentEdge` object and ignore *falsy* values.

The `IndentEdge` is just a Plain JavaScript Object with the properties:

 - `startToken:Token`: points to token that delimits the indent start (eg. a token
   with value "{")
 - `endToken:Token`: pointer to a token that sets the last token that should be
   indented (eg. a line break just before `]`)
 - `level:Int` (optional): sets how many indents should be added for that
   `IndentEdge`, that is very useful for cases where you might have different
   options for the same parent node (eg. the `FunctionExpression` hook also
   handles the `ParameterList` indentation); if `level <= 0` that *edge* is not
   indented (we don't support negative indent so far)

If the hook doesn't implement `getIndentEdges` we consider `node.startToken`
and `node.endToken` as the default edge. We only indent nodes that have a value
greater than zero on the configuration options.

Also important to notice that we only add `Indent` tokens to the beginning of
lines and if `edge.startToken` is `{` or `[` or `(` we use the
`edge.startToken.next` as the first token since that is usually the expected
behavior (you want to indent what is inside the braces/parenthesis).

The reason why we decided to handle indentation as multiple `IndentEdge`s is
because there are many cases where the lines between `node.startToken` and
`node.endToken` are not really the *range* that you want to indent (eg. on
`IfStatement` you what to indent the `test`, `consequent` and `alt` but not the
lines that open/close the curly braces). Trying to handle all the cases
automatically is a path doomed to failure. This is the most flexible
abstraction, and cleanest implementation, that we could think of so far but it
is indeed complex; it would be way easier if we had a real CST (concrete syntax
tree) but that ship already sailed.

## Branches and Pull Requests

We will create `-wip` branches (work in progress) for *unfinished* features
(mostly because of failing tests) and try to keep master only with *stable*
code. We will try hard to not rewrite the commit history of `master` branch but
will do it for `-wip` branches.

If you plan to implement a new feature check the existing branches, I will push
all my local `-wip` branches if I don't complete the feature in the same day.
So that should give a good idea on what I'm currently working.

Try to split your pull requests into small chunks (separate features), that way
it is easier to review and merge. But feel free to do large refactors as well,
will be harder to merge but we can work it out. - see [issue-guidelines for
more info about good pull
requests](https://github.com/necolas/issue-guidelines/blob/master/CONTRIBUTING.md#pull-requests)

## Default Settings

The default settings should be as *conservative* as possible, [Google
JavaScript Style
Guide](http://google-styleguide.googlecode.com/svn/trunk/javascriptguide.xml)
should be used as a reference.

We have plans to support other presets like
[Idiomatic.js](https://github.com/rwldrn/idiomatic.js/) and [jQuery Style
Guide](http://contribute.jquery.org/style-guide/js).

## Tests

Tests are done by comparing the result of `esformatter.parse()` of files with
name ending on `-in.js` with the files `-out.js`. The folder
`test/compare/default` tests the default settings and files inside
`test/compare/custom` tests custom settings. Tests inside the `compare/custom`
folder should try to test the *opposite* of the default settings whenever
possible.

To run the tests install the `devDependencies` by running `npm install`
(only required once) and then run `npm test`.

`mocha` source code was edited to provide better error
messages. See [mocha/issues/710](https://github.com/visionmedia/mocha/pull/710)
for more info.

```sh
# runs all tests
npm test
# bail stops at first failed test
BAIL=true npm test
# GREP is used to filter the specs to run (only specs that contain "indent" in the name)
GREP='indent' npm test
# can also use "INVERT=true" to only execute specs that doesn't contain "cli" in the name
GREP=cli INVERT=true npm test
# to set the mocha reporter
REPORTER=dot npm test
# enable logging for the specified module
DEBUG=rocambole:br:* npm test
```

**protip:** files starting with double underscore (`__`) are on our
`.gitignore` file and won't be commited, so I usually have a `__tmp-in.js` and
`__tmp-out.js` test files that contains the bare minimum code that reproduces
the bug that I'm trying to fix and execute that with
`DEBUG=esformatter:*:*,rocambole:*:* GREP=tmp npm test` to get all the logs.

## IRC

We have an IRC channel [#esformatter on
irc.freenode.net](http://webchat.freenode.net/?channels=esformatter) for quick
discussions about the project development/structure.


text:
# TrafficLightProject
This is a simple app that shows how a traffic light sequence work to a person who has no knowledge of traffic lights nor the different colors that comes with it.

![Traffic Light Project Screens](trafficLight.png)

# License
See the [LICENSE](https://github.com/arvnq/TrafficLightProject/blob/master/LICENSE) file for more info.

repository: arvinq/TrafficLightProject

repo_name: arvinq/TrafficLightProject


text:
Dice Binders

By [Mullet Mafia Dev](https://www.roblox.com/groups/5018486/Mullet-Mafia-Dev#!/about) | [Download](https://www.roblox.com/library/5462736550/Dice-Binders) | [Source](https://github.com/Mullets-Gavin/DiceBinders)

Dice Binders is an elegant and easy solution to creating tag-based UI animations, functions, and events in your game. Inspired by Quenty's RDC 2020 talk on Binders, I realized I had been using that for animations & much more for a bit now, so it only makes sense to compile every animation I have ever created and put them in this module as an easy route for people to create UI animations seamlessly. Dice Binders allows you to simply apply your own functions as well! You can create an event that fires whenever a new tag is added or cloned on a part to execute code. I created the UI Animations based on my own previous experience on Roblox UI, and open sourcing them with my Binders module makes it easier than ever to slip in quick animations that can make your interface sharp.

## Why Dice Binders?
Dice Binders was created as an easy way to run code with tags. This handles everything you need and keeps the code nice and clean. This works exceptionally well with Roblox UI, since you can apply the pre-made tags to your UI and watch it animate. Dice Binders handles memory and prevents leaks when you remove a tag or an object with a tag. Who doesn't like being able to tag elements and watch them run right away?

## Installation
You can [grab the Roblox model here](https://www.roblox.com/library/5462736550/Dice-Binders). To download from GitHub, [go to this link](https://github.com/Mullets-Gavin/DiceBinders/releases) and download the most recent version. Afterwards, place the module into `ReplicatedStorage` so both the client and server can access it.

## Pre-installed Modules
**User Interface [UI]:**
Over 20+ pre-installed UI Animations you can use for click events, mouse hovering, gradient designs, and more! Check out all of the animations in my test game here:
https://www.roblox.com/games/5310533136/UI-Animations

*You can change all the UI animations intensity by opening the module and changing the number value!*

**Obby Actions:**
To showcase my Binders module more, I included 3 Obby modules that you can use to assign tags to parts that kill a player, make the player shoot forward, or even hide the part the player jumps on!

---

**Installing the Tags:**
I tagged every module (UI/Obby) so all you have to do is make sure you have [Tiffany's Tag Editor](https://www.roblox.com/library/948084095/Tag-Editor) installed and you should be able to select the module and hit "Import" to add the tag to your editor so you can then tag your parts or UI.

## Documentation

### DiceBinders:Start
```
:Start()
```
Initialize the module in the environment called in to start tracking and watching tags.

### DiceBinders:Shutdown
```
:Shutdown()
```
Shutdown the module and disable all tags and disconnect all events.

### DiceBinders:ConnectEvents
```
:ConnectEvents(specific,func) -- specific = object, func = function
```
Connect an object with the given tag that is a descendant of the `DataModel` to a tag function in the second parameter.  A tag function is the modules that are descendants of DiceBinders with the same name as the tag given that returns a function passed with the parameters of the object to fire and connect events.

*Example:*
```lua
DiceBinders:ConnectEvents(workspace.Baseplate,function(object)
	local event
	event = object.Touched:Connect(function(hit)
		print(hit.Name,'touched',object.Name,'!')
	end)
	return event
end)
```

### DiceBinders:DisconnectEvents
```
:DisconnectEvents(specific) -- specific = object
```
Disconnect all events tied to an object which was or is parented to the `DataModel`, passed in the function `:ConnectEvents`.

### DiceBinders:DisconnectAllEvents
```
:DisconnectAllEvents(tag) -- tag = tag name
```
Disconnect all the events on a specific tag name.

### Initialize
To initialize the binder, require the module and run `:Start()` to enable the binder in the environment called.
```lua
local DiceBinders = require(game:GetService('ReplicatedStorage'):WaitForChild('DiceBinders'))
DiceBinders:Start()
```

That's it! Now you can create module scripts in the Binders module that return a function with an event to fire whenever the tag is interacted with in your game. All you have to do is name the module the same name as your tag and you should be good to go. Some example module code looks like this:
```lua
-- Obby-KillBrick.lua
return function(object)
	if object:IsA('BasePart') then
		local event
		event = object.Touched:Connect(function(hit)
			local findPlr = game.Players:GetPlayerFromCharacter(hit.Parent)
			if findPlr then
				local findHumanoid = findPlr.Character:FindFirstChild('Humanoid')
				if findHumanoid then
					findHumanoid:TakeDamage(findHumanoid.MaxHealth)
				end
			end
		end)
		return event
	end
	return false
end
```
---
Made with ♥ by Mullets_Gavin & Mullet Mafia Dev

repository: Mullets-Gavin/DiceBinders

repo_name: Mullets-Gavin/DiceBinders


text:
CoolCoreBundle
=====

Provides functionalities to quickly build CRUD (but not only) applications  with Symfony, PostgreSQL and Dojo.
It integrates the following key technologies

- Symfony2
- Postgres 9.x (with plv8)
- Dojo Toolkit

optional:

- Activiti BPMN engine
- Rundeck scheduler
- Pentaho ETL (Kettle/Kitchen)

- ZMQ/Push notifications
- ReactPHP/PHP-PM

Some features
=============

- Uses an extended version of the Propel schema which allows the definition of extended attributes (lookups, triggers, default controls, views...)
- Generates and maintains additional SQL/Php files to ease the management of complex lookups and behaviours while maintaining referential integrity
- The database schema is extensible, which means that new fields can be defined with UI tools, then used in forms and lists as if they were physical fields. Uses Postgres JSON containers
- Multi tenancy (one schema file, multiple actual schemas configurable at runtime). Facilities to aggregate results from multiple schemas
- Automatic schema structure synchronization (via ApgDiff)
- Fully configurable database level auditing (generates and maintains audit schemas that can capture any modification done to the master records, even for files)
- File attachments to records, managed with a database index and file system (or cloud) storage
- Provides tools to build lists and forms which are rendered in the UI with Dojo/Dijit/Gridx, and are fully configurable by the user without code (all configurations remain in the database)
- In-database translations
- Provides Pentaho Kettle plugins to interact with the system via its REST interface
- Can render Activiti Workflows as if they were native wizards in the application

License
=======

MIT, see the attached LICENSE file

repository: eulogix/cool-core-bundle

repo_name: eulogix/cool-core-bundle


text:
# drywall

a lightweight, reference implementation of a punctum.im server

## About

drywall is the official reference implementation of a punctum.im server. It is written in Python and uses the Flask framework.

For more information about punctum.im and the punctum protocol, visit [punctum.im's official website](https://punctum.im).

drywall requires Python version 3.6 or above.

## Installation

Depending on your use-case, you may follow one of the guides below:

- [Setting up for development](docs/setup/development.md)
- [Setting up for production](docs/setup/production.md) (Note that drywall is beta-quality software and is currently primarily intended for demonstration purposes.)

## Contributing

We accept contributions! Read [the contribution guide](docs/contributing.md) for information on contributing, reading the code, code quality guidelines and submitting patches.

There are a few topics we're actively working on; see the pinned issues for more information.

You may also be interested in [contributing to the protocol](https://punctum.im/protocol/contributing).

repository: punctum-im/drywall

branch_name: refs/heads/develop

repo_name: punctum-im/drywall


text:
## prnsrv

### Why?

I regularly just want to dump the output from a program pointed at a server
endpoint. This prints out whatever is sent in the `prnsrv` logs.

### How to use?

1. cd into the repo
2. run either `go run prnsrv.go` or `go run prnsrv.go -port <port-number>`
3. if you want to install, run `go install`, then you can run it using
   `prnsrv` or `prnsrv -port <port-number>` as long as `GOBIN` is in your path.

### Other
There are better tools for this, this is just an easy thing for me to use.

repository: derwolfe/prnsrv

repo_name: derwolfe/prnsrv


text:
### Release 2019-05-15
* **AWS.Logger.NLog (1.3.2)**
    * Merged PR https://github.com/aws/aws-logging-dotnet/pull/71 NLog AWSTarget apply Layout logic to config-properties. Thanks [Rolf Kristensen](https://github.com/snakefoot)

### Release 2018-12-06
* **AWS.Logger.Core (1.3.1)**
    * Merged PR https://github.com/aws/aws-logging-dotnet/pull/53 adding the ability to flush the queued messages.
Also improving shutdown behavior. Thanks [Rolf Kristensen](https://github.com/snakefoot)
* **AWS.Logger.AspNetCore (1.4.1)**
    * Merged PR https://github.com/aws/aws-logging-dotnet/pull/46 adding support for scopes. Thanks [Stefan Over](https://github.com/Herdo)
    * Bumped dependency of AWS.Logger.Core to 1.3.1
* **AWS.Logger.Log4net (1.3.1)**
    * Merged PR https://github.com/aws/aws-logging-dotnet/pull/59 updating to version 2.0.8 of Log4net. Thanks [Aaron Amm](https://github.com/aaronamm)
    * Merged PR https://github.com/aws/aws-logging-dotnet/pull/59 with new Log4net sample. Thanks [Aaron Amm](https://github.com/aaronamm)
    * Bumped dependency of AWS.Logger.Core to 1.3.1
* **AWS.Logger.NLog (1.3.1)**
    * Bumped dependency of AWS.Logger.Core to 1.3.1
* **AWS.Logger.SeriLog (1.2.1)**
    * Bumped dependency of AWS.Logger.Core to 1.3.1

### Release 2018-07-23
* **AWS.Logger.Core (1.2.0)**
    * Break up large logging messages into sizes that CloudWatch Logs will accept. This change was done to handle the CloudwatchLogs restriction on the event size(256 KB as per https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch_limits_cwl.html). This is addressing the following GitHub issue: https://github.com/aws/aws-logging-dotnet/issues/40
    * Added validation to uphold CloudwatchLogs restriction on the batch size(1 MB as per https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/cloudwatch_limits_cwl.html).
* **AWS.Logger.AspNetCore (1.3.0)**
    * Updated nuspec file with the updated AWS.Logger.Core version
* **AWS.Logger.Log4net (1.2.0)**
    * Updated nuspec file with the updated AWS.Logger.Core version
* **AWS.Logger.NLog (1.2.0)**
    * Updated nuspec file with the updated AWS.Logger.Core version
* **AWS.Logger.SeriLog (1.1.0)**
    * Updated nuspec file with the updated AWS.Logger.Core version
    * Merged in PR https://github.com/aws/aws-logging-dotnet/pull/41 for adding ITextFormatter to format log messages

### Release 2018-02-23
* **AWS.Logger.NLog (1.1.6)**
    * Changed dependency for NetStandard 1.5 from NLog 5 to Nlog 4.5

### Release 2018-02-22
* **AWS.Logger.Core (1.1.7)**
    * Created AssemblyInfo.cs with correct version numbers
* **AWS.Logger.AspNetCore (1.2.6)**
    * Created AssemblyInfo.cs with correct version numbers
    * Updated nuspec file with the updated AWS.Logger.Core version
* **AWS.Logger.Log4net (1.1.6)**
    * Modified AssemblyInfo.cs with correct version numbers
    * Updated nuspec file with the updated AWS.Logger.Core version
* **AWS.Logger.NLog (1.1.5)**
    * Modified AssemblyInfo.cs with correct version numbers
    * Updated nuspec file with the updated AWS.Logger.Core version
* **AWS.Logger.SeriLog (1.0.2)**
    * Modified AssemblyInfo.cs with correct version numbers
    * Updated nuspec file with the updated AWS.Logger.Core version

### Release 2018-02-19
* **AWS.Logger.Core (1.1.6)**
* Fixes bug with logger background dying after an arbitrary amount of time. An exception would be thrown and since the catch was outside the main loop, the thread would exit.
* Simplified error handling from main loop
* Simplified main loop method by removing redundant checks
* Cancellation is not an error, and will no longer be logged as such. We were, but not consistently.

### Release 2018-01-04 00:02 UTC
* Modified AssemblyInfo.cs with correct version numbers for all the libraries
* **AWS.Logger.Core (1.1.4)**
    * Modified AssemblyInfo.cs with correct version number
* **AWS.Logger.AspNetCore (1.2.5)**
    * Created AssemblyInfo.cs with correct version numbers
    * Updated nuspec file with the updated AWS.Logger.Core version
* **AWS.Logger.Log4net (1.1.5)**
    * Modified AssemblyInfo.cs with correct version numbers
    * Updated nuspec file with the updated AWS.Logger.Core version
* **AWS.Logger.NLog (1.1.4)**
    * Modified AssemblyInfo.cs with correct version numbers
    * Updated nuspec file with the updated AWS.Logger.Core version
* **AWS.Logger.SeriLog (1.0.1)**
    * Modified AssemblyInfo.cs with correct version numbers
    * Updated nuspec file with the updated AWS.Logger.Core version

### Release 2017-12-11 00:02 UTC
* **AWS.Logger.SeriLog (1.0.0)**
    * Added support for SeriLog logging library.
* **AWS.Logger.Log4net (1.1.4)**
    * Added support for Log4net logging library for NetStandard1.5 framework.

### Release 2017-09-28 00:02 UTC
* **AWS.Logger.AspNetCore (1.2.4)**
    * Added exception logging for default ASP.NET Core formatter.

### Release 2017-08-22 00:02 UTC
* **AWS.Logger.AspNetCore (1.2.2)**
    * Fixed issue with **Profile** setting not getting used.

### Release 2017-07-25 10:30 UTC
* **AWS.Logger.Core (1.1.3)**
    * Updated the logic in AWSLoggerCore for creating a logstream. AWSLoggerCore library will try to use the sequence token in the response message of a log PutLogEventsAsync request for a maximum of 5 attempts, before creating a new logstream.
* **AWS.Logger.AspNetCore (1.2.2)**
    * Updated dependency to latest AWS.Logger.Core
* **AWS.Logger.Log4net (1.1.3)**
    * Updated dependency to latest AWS.Logger.Core
* **AWS.Logger.NLog (1.1.3)**
    * Updated dependency to latest AWS.Logger.Core

### Release 2017-06-23 21:30 UTC
* **AWS.Logger.Core (1.1.2)**
    * Pull request [#19](https://github.com/aws/aws-logging-dotnet/pull/19), fixing a NPE. Thanks to [Andrew Kazyrevich](https://github.com/andreister)
* **AWS.Logger.AspNetCore (1.2.1)**
    * Updated dependency to latest AWS.Logger.Core
* **AWS.Logger.Log4net (1.1.2)**
    * Updated dependency to latest AWS.Logger.Core
* **AWS.Logger.NLog (1.1.2)**
    * Updated dependency to latest AWS.Logger.Core

### Release 2017-06-22 21:30 UTC
* **AWS.Logger.AspNetCore (1.2.0)**
    * Pull request [#14](https://github.com/aws/aws-logging-dotnet/pull/14), adding support for custom formatters. Thanks to [Peter Deme](https://github.com/peterdeme).

### Release 2017-05-18 14:30 UTC
* **AWS.Logger.Core (1.1.1)**
    * Added LibraryLogFileName property to log errors encountered by AWSLoggerCore
    * Upgraded library to NetStandard1.5 framework to support System.Runtime.Loader v4.0.0
* **AWS.Logger.AspNetCore (1.1.1)**
    * Added LibraryLogFileName property to log errors encountered by AWSLoggerCore
    * Upgraded library to NetStandard1.5 framework to match AWS.Logger.Core framework
* **AWS.Logger.Log4net (1.1.1)**
    * Added LibraryLogFileName property to log errors encountered by AWSLoggerCore
* **AWS.Logger.NLog (1.1.1)**
    * Added LibraryLogFileName property to log errors encountered by AWSLoggerCore
    * Upgraded library to NetStandard1.5 framework to match AWS.Logger.Core framework
    * Corrected NLog nuspec file to add NLog 4.4.9 for framework v4.5.2
    * Upgraded AWS.Logger.NLog netcore package NLog dependency from v4.4.0-beta5 to 5.0.0-beta07

### Release 2017-05-08 14:30 UTC
* **AWS.Logger.Core (1.1.0)**
    * Added LogStreamNameSuffix property to custom name logStream on CloudWatchLogs
* **AWS.Logger.AspNetCore (1.1.0)**
    * Added LogStreamNameSuffix property to custom name logStream on CloudWatchLogs
* **AWS.Logger.Log4net (1.1.0)**
    * Added LogStreamNameSuffix property to custom name logStream on CloudWatchLogs
* **AWS.Logger.NLog (1.1.0)**
    * Added LogStreamNameSuffix property to custom name logStream on CloudWatchLogs
    * Corrected NLog nuspec file to show dependency on the AWS.Logger.Core

### Release 2016-12-20 09:00 UTC
* **AWS.Logger.Core (1.0.0)**
    * Initial Release
* **AWS.Logger.AspNetCore (1.0.0)**
    * Initial Release
* **AWS.Logger.Log4net (1.0.0)**
    * Initial Release
* **AWS.Logger.NLog (1.0.0)**
    * Initial Release


text:
[Wholenote](https://appdemo.carlegbert.com "Wholenote") is a [Flask](http://flask.pocoo.org "Flask")-powered RESTful API for storing plaintext notes.

Written by [Carl Egbert](http://www.carlegbert.com) - [egbertcarl@gmail.com](mailto:egbertcarl@gmail)

### Authorization

Wholenote uses access and refresh tokens to handle authentication, via [flask-jwt-extended](https://github.com/vimalloc/flask-jwt-extended).
Access tokens are short-lived (15 minutes, in this case) JSON web tokens that are used to access, create, or modify protected data.
Once the access token expires, a refresh token will need to be used to obtain a new one. A succesful login request will return both an access
and a refresh token. The refresh token should be securely stored by the client. More explanation is provided in the API endpoint documentation.

### API Endpoints

See documentation [here](API_ENDPOINTS.md)

repository: carlegbert/wholenote

repo_name: carlegbert/wholenote


text:
# Python Container

This image adds a working Python environment to `databricksruntime/minimal` using virtualenv, and is supported for Databricks Runtime 7.3 LTS and above.
For a conda-based Python environment, an alternative image can be found [here](https://github.com/databricks/containers/tree/master/ubuntu/python-conda).
Note that Databricks recommends using this recipe unless you need libraries that are only available from conda, as certain features like notebook-scoped libraries (e.g. `%pip`) will not work with the conda recipe in newer runtimes (Databricks Runtime 9.0 and above).

## Supported Features
  - Scala Notebooks
  - Java/Jar jobs
  - Python Notebooks, Python Jobs, `%pip`
  - `%sh`
  - Spark Submit Jobs

## Unsupported Features
  - DBFS FUSE mount (/dbfs)
  - Ganglia
  - SSH

repository: databricks/containers

gha_language: Dockerfile

repo_name: databricks/containers


text:
# CricEngine

Developed in 2009-2010 by ![Thomas MALICET](http://www.thomasmalicet.com), CricEngine is a publishing software for online magazines, publications etc.

Functionalities
- text editor and layout manipulation
- page management and automatic table of content
- image and sound upload
- sound player
- automatic sync with a MySQL database through PHP

![alt text](/lib/screencap.jpg)

Made with Adobe Air for desktop.

repository: Wanchai/CricEngine

repo_name: Wanchai/CricEngine


text:
# @putout/operator-declare [![NPM version][NPMIMGURL]][NPMURL]

[NPMIMGURL]: https://img.shields.io/npm/v/@putout/operator-declare.svg?style=flat&longCache=true
[NPMURL]: https://npmjs.org/package/@putout/operator-declare "npm"

🐊[**Putout**](https://github.com/coderaiser/putout) operator adds ability to declare variables that has references with no definitions. Most likely you prefer using [Declarator](https://github.com/coderaiser/putout/blob/master/packages/engine-runner/README.md#Declarator) plugin type based on current Operator.

## Install

```
npm i putout @putout/operator-declare
```

## API

If you want to create 🐊[**Putout**](https://github.com/coderaiser/putout) `plugin` that will declare variables according to your needs just:

```js
const {operator} = require('putout');
const {declare} = operator;

module.exports = declare({
    fs: `import fs from 'fs/promises'`,
});
```

### Dual packages

When you need different declarations for `ESM` and `CommonJS` you can use:

```js
const {operator} = require('putout');
const {declare} = operator;

module.exports = declare({
    fs: {
        esm: `import fs from 'fs/promises'`,
        comomnjs: `const fs = require('fs')`, // drop when not needed
    },
});
```

### Configuration

Plugin supports options, so you can pass it in `.putout.json`:

```json
{
    "rules": {
        "putout/declare": ["on", {
            "declarations": {
                "fs": "import fs from 'fs/promises'"
            }
        }]
    }
}
```

If for some reason you don't need some kind of declaration, add `dismiss` field and it will be ignored:

```json
{
    "rules": {
        "putout/declare": ["on", {
            "declarations": {
                "fs": "import fs from 'fs/promises'"
            },
            "dismiss": ["fs"]
        }]
    }
}
```

### Used in

- ✅ [declare](https://github.com/coderaiser/putout/tree/master/packages/plugin-declare#readme)
- ✅ [tape/declare](https://github.com/coderaiser/putout/tree/master/packages/plugin-tape#declare)
- ✅ [putout/declare](https://github.com/coderaiser/putout/tree/master/packages/plugin-putout#declare)
- ✅ [nodejs/declare](https://github.com/coderaiser/putout/blob/master/packages/plugin-montag/#declare)
- ✅ [react-hooks/declare](https://github.com/coderaiser/putout/blob/master/packages/plugin-react-hooks/README.md#declare)
- ✅ [try-catch/declare](https://github.com/coderaiser/putout/blob/master/packages/plugin-try-catch/#declare)
- ✅ [montag/declare](https://github.com/coderaiser/putout/blob/master/packages/plugin-montag/#declare)
- ✅ [madrun/declare](https://github.com/coderaiser/putout/blob/master/packages/plugin-madrun/#declare)
- ✅ [maybe/declare](https://github.com/coderaiser/putout/tree/master/packages/plugin-maybe#declare)

### Evaluate

Can be used with **ESLint's** [putout/evaluate](https://github.com/coderaiser/putout/tree/master/packages/eslint-plugin-putout/lib/evaluate#readme):

```json
{
    "rules": {
        "putout/declare": ["on", {
            "declarations": {
                "superMethod": "import superMethod from '__putout_evaluate: join(`./`, basename(__filename), `.js`)'"
            }
        }]
    }
}
```

If you have a file `index.spec.js`:

```diff
+ import superMethod from './index.js'
superMethod();
```

## License

MIT

repository: coderaiser/putout

repo_name: coderaiser/putout


text:
#  ✏ FullStack-FlashCardApp

### This application allows user to log in under their individual accounts and save their flash cards under their email.  They can then enter anytime in the future and study their cards.

### While in their account they can create headers for their notes and content. They can easily click on the cards to flip them over.  When they have finished studying just simply click on the trash can to throw the card away.

![alt text](login-screenShot.png)
![alt text](profile-screenshot.png)

## Tech Used:
- HTML5
- CSS3
- Javascript
- Node.js
- Express
- Mongo DB
- say.js

## Installation

1. Clone repo
2. run `npm install`

## Usage

1. run `node server.js`
2. Navigate to `localhost:3000`
3. Have fun ;)

## Credit

Modified from Scotch.io's auth tutorial

repository: mauricioTechDev/FullStack-FlashCardApp

repo_name: mauricioTechDev/FullStack-FlashCardApp


text:
# Azure Machine Learning Data Prep Public Preview

The Azure Machine Learning Data Prep SDK is used to load, transform, and write data for machine learning workflows. You can interact with the SDK in any Python environment, including Jupyter Notebooks or your favorite Python IDE. The Azure Machine Learning Data Prep SDK includes the following set of functionalities to help prepare your data for modeling:

- Intelligent transforms: Use the SDK to derive or split a column by example, impute missing values, fuzzy group, auto join, and perform other automated tasks.
- Auto reading functionality: The SDK can automatically detect any of the supported file types. You don’t need to use special file readers for CSV, text, Excel, etc., or to specify delimiter, header, or encoding parameters.
- Varying schema processing: The SDK engine can read different columns per row instance, also sometimes referred to as ragged-right format.
- Scale through streaming: Instead of loading all the data into memory, the SDK engine serves data using streaming, allowing it to scale and perform better on large datasets.
- Cross-platform functionality with a single code artifact: Write to a single SDK and run it on Windows, macOS, Linux, or Spark in a scale-up or scale-out manner. When running in scale-up, the engine attempts to utilize all hardware threads available, when running scale-out the engine allows the distributed scheduler to optimize execution.

## Installation
### Data Prep SDK
Install from PyPI:
```
 pip install --upgrade azureml-dataprep
```
## New Azure ML Data Prep API

Here are examples on how to use the new Data Prep API:
- [Getting Started Tutorial](tutorials/getting-started/getting-started.ipynb)
- [How-To Guides](how-to-guides)
- [Case Study](case-studies/new-york-taxi)
- [API Reference Docs](http://aka.ms/data-prep-sdk)

## Known Issues

- **If running version 0.1.0**: To fix "Error Message: Cannot run the event loop while another loop is running", downgrade Tornado version to 4.5.3. Restart any running kernels for the change to take effect.
```
pip install -U tornado==4.5.3
```
## Release Notes
### 2018-12-03
Breaking changes:
 - `SummaryFunction.N` was renamed to `SummaryFunction.Count`.

Bug Fixes:
 - Use latest AML Run Token when reading from and writing to datastores on remote runs. Previously, if the AML Run Token is updated in Python, the Data Prep runtime will not be updated with the updated AML Run Token.
 - Additional clearer error messages
 - to_spark_dataframe() will no longer crash when Spark uses Kryo serialization
 - Value Count Inspector can now show more than 1000 unique values
 - Random Split no longer fails if the original Dataflow doesn’t have a name

### 2018-11-19

New Features:
- Created a new DataPrep CLI to execute DataPrep packages and view the data profile for a dataset or dataflow
- Redesigned SetColumnType API to improve usability
- Renamed smart_read_file to auto_read_file
- Now includes skew and kurtosis in the Data Profile
- Can sample with stratified sampling
- Can read from zip files that contain CSV files
- Can split datasets row-wise with Random Split (e.g. into test-train sets)
- Can get all the column data types from a dataflow or a data profile by calling .dtypes
- Can get the row count from a dataflow or a data profile by calling .row_count

Bug Fixes:
- Fixed long to double conversion
- Fixed assert after any add column
- Fixed an issue with FuzzyGrouping, where it would not detect groups in some cases
- Fixed sort function to respect multi-column sort order
- Fixed and/or expressions to be similar to how Pandas handles them
- Fixed reading from dbfs path.
- Made error messages more understandable
- Now no longer fails when reading on remote compute target using AML token
- Now no longer fails on Linux DSVM
- Now no longer crashes when non-string values are in string predicates
- Now handles assertion errors when Dataflow should fail correctly
- Now supports dbutils mounted storage locations on Azure Databricks

### 2018-11-05

New Features:
- Type Count added to Data Profile
- Value Count and Histogram is now available
- More percentiles in Data Profile
- The Median is available in Summarize
- Python 3.7 is now supported
- When you save a dataflow that contains datastores to a Data Prep package, the datastore information will be persisted as part of the Data Prep package
- Writing to datastore is now supported

Bug Fixes:
- 64bit unsigned integer overflows are now handled properly on Linux
- Fixed incorrect text label for plain text files in smart_read
- String column type now shows up in metrics view
- Type count now is fixed to show ValueKinds mapped to single FieldType instead of individual ones
- Write_to_csv no longer fails when path is provided as a string
- When using Replace, leaving “find” blank will no longer fail

## Datasets License Information
IMPORTANT: Please read the notice and find out more about this NYC Taxi and Limousine Commission dataset here: http://www.nyc.gov/html/tlc/html/about/trip_record_data.shtml

IMPORTANT: Please read the notice and find out more about this Chicago Police Department dataset here: https://catalog.data.gov/dataset/crimes-2001-to-present-398a4

repository: krishnamuthan/AMLDataPrepDocs

repo_name: krishnamuthan/AMLDataPrepDocs


text:
---
title: It week 6
layout: post
author: rory.davies
permalink: /it-week-6/
source-id: 1IoohduRUUuwT-zR6_4FLKM12lrZ3AV4irQ5jBw9xM4g
published: true
---

    Title
    It Week 6
    Date
    11/10/16

    Starting point:
    The place in the booklet we got to last

    Target for this lesson?
    See How HVTAB is useful  (allows us to position the text cursor anywhere on the screen 0,0 is top left)

    Did I reach my target?
(add details to "Lesson Review")
     yes i was able to see how to use and know what HVTAB is used for and how to use it

    Lesson Review

    How did I learn? What strategies were effective?

    I found that for words you found struggling there is a margin that usually contains the words meaning but not how to change it i found out that 0,0 is top left so if change the first 0 it will change the along the side and the other 0 will change it length ways. We used this in space invaders task and we were able to change its position on screen from using this.

    What limited my learning? Which habits do I need to work on?

    I believe compared to the previous weeks this was one of our most successful as me and my partner drastically improved as we were able to catch up with the group next to us who started 6 pages before and were able to down grade it to just a 1 page difference between us.

    What will I change for next time? How will I improve my learning?

    Next time i'll try and stick to the pros that we did today and use them in the following lessons to really boost our learning and capability. But if there is a con we can take away from this lesson i believe it would most likely be not skim reading which i think would save a lot of time and still be able to identify the same things.


text:
---
title: Available NuGet Packages
page_title: Available NuGet Packages
description: Telerik UI for WinForms provides a set of NuGet packages targeting different .NET versions.
slug: winforms-available-nugets
tags: install, nuget
published: True
position: 5
---

# Available NuGet Packages

Telerik UI for WinForms comes with several different packages that can be [installed via the Telerik server or from a local package source]({%slug winforms/nuget%}):

![winforms-available-nugets001](images/winforms-available-nugets001.png)

The Telerik assemblies are built against [different versions]({%slug assemblies-version%}) of .NET starting from .NET 4 to the latest official .NET. You should pick up this version of the NuGet package to install in your project that corresponds to the Target Framework that you are using in your project and that is available on your computer.

>important The last NuGet package for .NET 2.0 is version 2022.2.622.

## Full Packages

`Telerik_UI_for_WinForms_<version number>_NuGet_Dev.zip` contains `.nupkg` files for the following full packages:

* `UI.for.WinForms.AllControls.Net40`
* `UI.for.WinForms.AllControls.Net48`
* `UI.for.WinForms.AllControls.Net60`
* `UI.for.WinForms.AllControls.Net70`
* `UI.for.WinForms.AllControls.NetCore`

Each of these packages contains all Telerik UI for WinForms assemblies for the corresponding .NET framework/ .NET Core/ .NET version.

## Separate Packages

`Telerik_UI_for_WinForms_<version number>_NuGet_Dev.zip` contains `.nupkg` files for the separate packages for each Telerik assembly:

* `UI.for.WinForms.Common`
* `UI.for.WinForms.GridView`
* `UI.for.WinForms.PdfViewer`
* `UI.for.WinForms.Scheduler`
* `UI.for.WinForms.Theme`
* `UI.for.WinForms.SyntaxEditor`
*  .etc

Each of these packages contain the corresponding Telerik dll for all available .NET frameworks (.40, .45, 4.8, etc.), .NET Core versions (3.0, 3.1, etc.), .NET 5.0, 6.0, 7.0 or newer . In case the dll is dependent on another Telerik dll, the required package will be installed automatically.

>note As the AllControls package contains all UI controls and themes it should not be installed in projects having other packages containing the UI controls (e.g. UI.for.WinForms.Common etc.) or the UI.for.WinForms.Themes package. Either use the AllControls package or the packages of the separate controls and the themes.

## Telerik NuGet Server Packages

There is an [online package source]({%slug winforms/nuget%}) that can be used to get Telerik NuGets.

## Installing Latest Internal Build NuGet Packages

You can install and test the [Latest Internal Build]({%slug winforms/installation-deployment-and-distribution/latest-internal-builds%}) (LIB) dlls provided on a occasional basis, via the NuGet Package Manager.

![winforms-available-nugets002](images/winforms-available-nugets002.png)

The LIB NuGets are available only as .nupkg files that can be downloaded from your telerik.com account as well:

![winforms-available-nugets003](images/winforms-available-nugets003.png)

# See Also

* [Installing On Your Computer]({%slug winforms/installation-deployment-and-distribution/installing-on-your-computer%})
* [How to Upgrade a Telerik UI for WinForms Project]({%slug how-to-upgrade-a-project%})
* [Install NuGet Key]({%slug install-nuget-keys%})

repository: telerik/winforms-docs

repo_name: telerik/winforms-docs


text:
# _Group Week PHP_

#### _Group Project week 5 PHP 2017_

#### By _**Max Larson, Eliot Carlsen, Rob Mckenzie, Zach Beecher, Xing Li**_

## Description

_Social media web app that incorporates to do lists, that can be assigned to users of groups by the admin of said group. See the composer.json file for project dependencies._
https://github.com/MLarson90/group-project
## Setup/Installation Requirements

* _Download or clone project files_
* _Run Composer Install or Composer Update in terminal_
* _Run MAMP / WAMP and target web folder of this project directory_

## Specs (include project specs below)
* _spec 1 A web app that allows the user to create an account_
* _spec 2 A user can log in with their created account_
* _spec 3 A user can enter their bio_
* _spec 4 A user can enter their profile picture URL_
* _spec 5 A user can join groups_
* _spec 6 A user can invite their friends to groups_
* _spec 7 A admin of a group can assign a to do task to a member of the same group_
* _spec 8 An user will get updates on their home page about tasks they have been assigned_

## Known Bugs

_No known bugs,_

## Support and contact details

_If you run into any issues or have questions, ideas or concerns, please contact Rob at 1-800-TEAMROB (1-800-832-6762)_

## Technologies Used
* _Bootstrap 3.3.7_
* _JQuery 3.2.0_
* _Silex 1.1_
* _Twig 1.0_
* _PHPUnit 4.5.*_

### License

*This project is licensed under the MIT license*

Copyright (c) 2017 **_Max Larson and team_**


text:
/*
Title: Why having a startup office outside Block 71 might be better
Date: 2014/03/15
Description: When HeartCode decided to move into Woodlands 11 instead of Blk 71 Ayer Rajah Crescent, there were many reasons behind the consideration.
Author: Sam Yong
Tags: rental,company,office
*/

![Blk 71 Ayer Rajah Crescent](http://farm7.staticflickr.com/6144/5976861368_f2e19b44a3_b.jpg)
[Innov8 Incubator / Blk 71, Ayer Rajah Crescent, Singapore 139951](http://www.flickr.com/photos/morle/5976861368/) by Phil Morle

"Why didn't you move into Ayer Rajah Crescent? Isn't that where all the tech startups are?" Those were the very questions our computer science / engineering / startup friends ask when [HeartCode moved into Woodlands 11](http://blog.heartcode.sg/posts/2014/Jan/1-new-year-new-office).

The [tech community in Ayer Rajah](http://beyondthevalley.co/2012/06/03/block-71-singapores-hidden-secret/) grew greatly following the opening of one-north MRT station on the circle line and launch of many tech events and initiatives over the past years. With the [recent developments and plans](http://www.techinasia.com/singapores-block-71-double-capacity-2014/) that the Singapore Government has for the startup community, it led me to think that it is important for startups to carefully evaluate where work from and to plant their first office.

> "Totally spot on! If you are building a startup in SG, (Blk 71) is the place to be!"
> <small>Bryan Lee, comment on Block 71: Singapore's innovation secret.</small>

###Cafe Startup

Before 1 Jan 2014, members of the HeartCode team worked from either home, study areas in school or a cafe like Starbucks or Coffee Bean and Tea Leaf. That was the norm for us for over a year, and we do it weekly.

> Here's a bonus: at one point of time we were regulars at the Starbucks tucked away behind Bishan MRT Station. The quaint cafe at Bishan Community Centre has a very nice study/work table in the center. During non-peak, Starbucks Bishan is our defacto choice over crowded cafes near MRT stations.

Working at home, study areas or cafe is definitely much cheaper than renting an office. We saved a lot of money on rental and office space. It is also said that working in a cafe boosts [productivity and creativity](http://coffitivity.com/).

Eventually we decided to rent and [hire to propel](http://heartcode.sg/jobs) our company growth.

###Building a company that provides service

At HeartCode, we provide software development services with value-adding Corporate Social Responsibility programme. Our clients approached HeartCode for requirements-fitting software development often result in greater organisation efficiency and streamlined processes.

On the other hand, most startups in Blk 71 focuses on one app or software as their product - and often they have their "Chief Technology Officer" and programmers on their founding team to create a minimum viable product. There is little match between what we do vs what the Ayer Rajah community do.

It would be difficult for HeartCode to work out deals with the other startups at Blk 71.

###An office space for the people in it

> Too many twenty-something founders look for employees just like themselves. “So you discriminate against anyone who is in their 30s or 40s or has a family,” says [Matt Mickiewicz from Hired](http://www.fastcolabs.com/3018568/why-your-startup-cant-find-developers). “But the most talented and experienced people will be in their 30s and 40s."

As the founding team consists of all twenty-something, we hope to build a family-friendly company that allows the most talented and experienced people to unleash their potential to the fullest in a cubicle-free software development studio.

Our office is in a business hub community located conveniently by Admiralty MRT Station. There are 3 childcare centres, several food courts with affordable price around $2.50 to $3.00, Shogun Fight Gym (Silat, Judo, Muay Thai - on level 8) and even a wedding dress boutique on our floor!

The environment must be able to support the lifestyle and work-life balance of the people working there. That to us is more important than having the company at the tech and innovation community. If you feel like you are at home while working, then work will definitely be enjoyable.

###Spotlight in a diversified community

With over 400 other units in Woodlands 11 that does mainly warehousing, supply chain, hardware and furniture, it becomes easy for our neighbours to remember us as "the software development studio". There is much development potential in this community to us, than in 71 Ajer Rajah Crescent.

###Conclusion

Blk 71 is a great place for innovation and technology development, away from the overcrowded Central Business District area. However, it is not suited for all startups and founders should include options in the heartlands in consideration of a workspace.

---
**Sam Yong** envisions how computing and infocomm technology can empower the society and bring people to greater heights. He is co-founded [HeartCode](http://heartcode.sg/) and writes code for open-source on [Github](https://github.com/mauris).


text:
## Useful tools

We provide lots of useful tools under `tools/` directory.

### Get the FLOPs and params (experimental)

We provide a script adapted from [flops-counter.pytorch](https://github.com/sovrasov/flops-counter.pytorch) to compute the FLOPs and params of a given model.

```shell
python tools/get_flops.py ${CONFIG_FILE} [--shape ${INPUT_SHAPE}]
```

For example,
```shell
python tools/get_flops.py configs/resotorer/srresnet.py --shape 40 40
```
You will get the result like this.

```
==============================
Input shape: (3, 40, 40)
Flops: 4.07 GMac
Params: 1.52 M
==============================
```

**Note**: This tool is still experimental and we do not guarantee that the number is correct. You may well use the result for simple comparisons, but double check it before you adopt it in technical reports or papers.

(1) FLOPs are related to the input shape while parameters are not. The default input shape is (1, 3, 250, 250).
(2) Some operators are not counted into FLOPs like GN and custom operators.
You can add support for new operators by modifying [`mmcv/cnn/utils/flops_counter.py`](https://github.com/open-mmlab/mmcv/blob/master/mmcv/cnn/utils/flops_counter.py).

### Publish a model

Before you upload a model to AWS, you may want to
(1) convert model weights to CPU tensors, (2) delete the optimizer states and
(3) compute the hash of the checkpoint file and append the hash id to the filename.

```shell
python tools/publish_model.py ${INPUT_FILENAME} ${OUTPUT_FILENAME}
```

E.g.,

```shell
python tools/publish_model.py work_dirs/example_exp/latest.pth example_model_20200202.pth
```

The final output filename will be `example_model_20200202-{hash id}.pth`.

### Convert to ONNX (experimental)

We provide a script to convert model to [ONNX](https://github.com/onnx/onnx) format. The converted model could be visualized by tools like [Netron](https://github.com/lutzroeder/netron). Besides, we also support comparing the output results between Pytorch and ONNX model.

```bash
python tools/pytorch2onnx.py
    ${CFG_PATH} \
    ${CHECKPOINT_PATH} \
    ${MODEL_TYPE} \
    ${IMAGE_PATH} \
    --trimap-path ${TRIMAP_PATH} \
    --output-file ${OUTPUT_ONNX} \
    --show \
    --verify \
    --dynamic-export
```

Description of arguments:

- `config` : The path of a model config file.
- `checkpoint` : The path of a model checkpoint file.
- `model_type` :The model type of the config file, options: `inpainting`, `mattor`, `restorer`, `synthesizer`.
- `image_path` : path to input image file.
- `--trimap-path` : path to input trimap file, used in mattor model.
- `--output-file`: The path of output ONNX model. If not specified, it will be set to `tmp.onnx`.
- `--opset-version` : ONNX opset version, default to 11.
- `--show`: Determines whether to print the architecture of the exported model. If not specified, it will be set to `False`.
- `--verify`: Determines whether to verify the correctness of an exported model. If not specified, it will be set to `False`.
- `--dynamic-export`: Determines whether to export ONNX model with dynamic input and output shapes. If not specified, it will be set to `False`.

**Note**: This tool is still experimental. Some customized operators are not supported for now. And we only support `mattor` and `restorer` for now.

repository: liu-xb/mmediting

repo_name: liu-xb/mmediting


text:
# Dual Self-Paced Graph Convolutional Network: Towards Reducing Attribute Distortions Induced by Topology

```
@inproceedings{dspgcn_ijcai19,
  title     = {Dual Self-Paced Graph Convolutional Network: Towards Reducing Attribute Distortions Induced by Topology},
  author    = {Yang, Liang and Chen, Zhiyang and Gu, Junhua and Guo, Yuanfang},
  booktitle = {Proceedings of the Twenty-Eighth International Joint Conference on Artificial Intelligence (IJCAI)},
  pages     = {4062--4069},
  year      = {2019}
}
```

links
- [ijcai](https://www.ijcai.org/proceedings/2019/564)

gha_language: Jupyter Notebook


text:
#     Github

Delete a user migration archive

Deletes a previous migration archive. Downloadable migration archives are automatically deleted after seven days. Migration metadata, which is returned in the [List user migrations](https://developer.github.com/v3/migrations/users/#list-user-migrations) and [Get a user migration status](https://developer.github.com/v3/migrations/users/#get-a-user-migration-status) endpoints, will continue to be available even after an archive is deleted.

Method: Delete

OperationID: migrations/delete-archive-for-authenticated-user

EndPoint:

/user/migrations/{migration_id}/archive

url: https://raw.githubusercontent.com/Ayehu/custom-activities/32729dddfbe7fb74dbd0179bba01978dccf84b1b/Github/migrations/GH Delete a user migration archive/Readme.md

repository: Ayehu/custom-activities

gha_language: C#

repo_name: Ayehu/custom-activities


text:
---
title: How can my retirement community or independent living facility prepare for COVID-19?
category: retirement-communities
layout: post
date: March 20, 2020
source: CDC
promoted: false
source_url: https://www.cdc.gov/coronavirus/2019-ncov/community/retirement/faq.html
excerpt: Retirement communities
---

[Administrators should take the following actions to prevent a COVID-19 outbreak in their community or facility:](https://www.cdc.gov/coronavirus/2019-ncov/community/retirement/guidance-retirement-response.html)

- Promote social distancing
  - Cancel public or group activities and events
  - Inform workers and volunteers to avoid close contact with residents
  - When possible, limit visitors and volunteers to essential persons
  - Advise residents to stay home and avoid public places
  - Alter schedules to reduce mixing (e.g., stagger meal, activity, arrival/departure times)
- Support residents in preparing
  - Establish the ‘buddy’ system to ensure residents stay connected.
  - Encourage residents to have extra medications and supplies.
  - Identify residents with unique needs and work with them to tailor these strategies.
  - Find ways to support residents in [managing stress and anxiety](https://www.cdc.gov/coronavirus/2019-ncov/prepare/managing-stress-anxiety.html).
  - Inform residents using print materials and high-visibility posters
- Encourage everyone to take [everyday preventive actions](https://www.cdc.gov/coronavirus/2019-ncov/about/prevention-treatment.html) to prevent the spread of respiratory illnesses.
  - Cover coughs and sneezes
  - Clean and disinfect frequently touched surfaces
  - Wash hands often with soap and water for at least 20 seconds
  - Ensure hand hygiene supplies (e.g., hand sanitizer containing at least 60% alcohol) are readily available in all buildings.
- Monitor for cases and take action when someone is sick.
  - Screen workers and when possible volunteers
  - Ask residents to self-monitor for symptoms
  - Review the usual absenteeism patterns at your facility among staff, so you can identify if the rate of absenteeism increases.
  - Implement flexible sick-leave policies and actively encourage sick employees to stay home
  - Coordinate with local health facilities if you suspect a resident or staff member may have COVID-19

repository: mayonissen/coronavirus-answers

repo_name: mayonissen/coronavirus-answers


text:
# [Even Fibonacci Numbers](https://projecteuler.net/problem=2)

### Problem 002

Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, the first 10 terms will be:

1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ...

Find the sum of the even-valued terms below *n*.

---

## How to Use

#### **C++**

* Run `g++ evenFibonacciNumbers.cpp` to compile.
* Run `a.out` from the command line.
* Enter a max fibonacci value, *n*, and hit enter.

#### **JavaScript**

* Open `evenFibonacciNumbers.html` in your browser.
* Enter a max fibonacci value, *n*, in the textbox and click **submit**.

#### **PHP**

* Run `php evenFibonacciNumbers.php` from the command line.
* Enter a max fibonacci value, *n*, and hit enter.

#### **Python3**

* Run `python3 evenFibonacciNumbers.py` from the command line.
* Enter a max fibonacci value, *n*, and hit enter.


text:
# AI-Communication BETA

This is a library to connect AI of Cupen Systems with any framework.

## Installation

  `npm install ai-communication`

## Usage

## Tests

  `npm test`

## Contributing

repository: fcupen/ai-communication

repo_name: fcupen/ai-communication


text:
# API

## mapSlice

params: { name, initialState, extraReducers }

## assignSlice

params: { name, initialState, extraReducers }

## loadingSlice

params: { name, extraReducers }

## createSlice

This is the default export for robodux and will automatically create actions,
reducer, and selectors for you.

```
{
  name: string, // required
  useImmer: boolean, // default, true, determines whether or not to use immer
  initialState: any, // the initial state for the reducer
  reducts: object, // the action to reducer map
}
```

## createAction

This is the helper function that `robodux` uses to create an action. It is also
useful to use when not using robodux because when stringifying the function it
will return the action type. This allows developers to not have to worry about
passing around action types, instead they simply pass around action creators for
reducers, sagas, etc.

```ts
import { createAction } from 'robodux';

const increment = createAction('INCREMENT');
console.log(increment);
// -> 'INCREMENT'
console.log(increment(2));
// { type: 'INCREMENT', payload: 2 };
const storeDetails = createAction('STORE_DETAILS');
console.log(storeDetails);
// -> 'STORE_DETAILS'
console.log(storeDetails({ name: 'John', surname: 'Doe' }));
// { type: 'INCREMENT', payload: {name: 'John', surname: 'Doe'} };
```

## createReducer

This is the helper function that `robodux` uses to create a reducer. This
function maps action types to reducer functions. It will return a reducer.

```
{
  initialState: any, // the initial state for the reducer
  reducers: object, // the action to reducer map
  name: string, // optional, sends value to `toString`
  useImmer: boolean, // default, true, determines whether or not to use immer
}
```

```ts
import { createReducer } from 'robodux';

const counter = createReducer({
  initialState: 0,
  reducers: {
    INCREMENT: (state) => state + 1,
    DECREMENT: (state) => state - 1,
    MULTIPLY: (state, payload) => state * payload,
  }
});

console.log(counter(2, { type: 'MULTIPLY': payload: 5 }));
// -> 10
```

## createActionMap (v5.0.0)

This is a helper function to combine actions from multiple slices. This is
create when composing multiple slices into a module that will then be exported.

```ts
import { createSlice, createActionMap } from 'robodux';

const counter = createSlice({
  name: 'counter',
  initialState: 0,
  reducts: {
    increment: (state) => state + 1,
    decrement: (state) => state - 1,
  },
});

const loading = createSlice({
  name: 'loading',
  initialState: false,
  reducts: {
    loading: (state, payload) => payload,
  },
});

/*
This is the same as doing this:
const actions = {
  ...counter.actions.
  ...loading.actions,
};
*/
const actions = createActionMap(counter, loading);
/*
{
  inc: (payload?: any) => Action<any>;
  dec: (payload?: any) => Action<any>;
  loading: (payload: boolean) => Action<boolean>;
}
*/

export { actions };
```

## createReducerMap (v5.0.0)

This is a helper function to combine reducers from multiple slices. This is
useful when composing multiple slices into a module that will then be exported.
This does _not_ use `combineReducers` under the hood, it simply creates an
object where the key is the slice name and the value is the reducer function.

```ts
import { createSlice, createReducerMap } from 'robodux';

const counter = createSlice({
  name: 'counter',
  initialState: 0,
  reducts: {
    increment: (state) => state + 1,
    decrement: (state) => state - 1,
  },
});

const loading = createSlice({
  name: 'loading',
  initialState: false,
  reducts: {
    loading: (state, payload) => payload,
  },
});

/*
This is the same thing as doing this:
const reducers = {
  [counter.name]: counter.reducer,
  [loading.name]: loading.reducer,
};
*/
const reducers = createReducerMap(counter, loading);
/*
{
  counter: Reducer<number, Action<any>>;
  loading: Reducer<boolean, Action<any>>;
}
*/

export { reducers };
```

## createApp

Given an array of modules with type `{ reducer: { [key: string]: Reducer } }` we
will combine the reducers using `combineReducers` from redux.

## Common reducers

All the following functions are primarily for creating new slice helpers by reusing the reducers we have built.

### mapReducers

These are the reducers used for `mapSlice`.

### assignReducers

These are the reducers used for `assignSlice`.

### loadingReducers

These are the reducers used for `loadingReducers`.

repository: cashc/robodux

repo_name: cashc/robodux


text:
---
layout: post
title: "Friday 11.02.18 -  CrossFit"
teaser: "A.  10 minute EMOM of Hang Cleans
 B.  5 Rounds For Time of Rope Climbs and Hang Squat Cleans
 C.  5 Rounds For Time of Rope Climbs and Hang Squat Cleans
 D.  Cool Down"
date: 2018-11-02 00:00:00
categories: wodup
tags: wods friday
header: no
---

A.  10 minute EMOM of Hang Cleans

Every 1 minute for 10 minutes (10 rounds):
– 2 Hang Cleans @ Max Load

Hang squat cleans for part A.

B.  5 Rounds For Time of Rope Climbs and Hang Squat Cleans

5 Rounds for Time:
– 1 Rope Climb 15 feet
– 4 Hang Squat Cleans @ 60/43 kg
REST 5 MINUTES

C.  5 Rounds For Time of Rope Climbs and Hang Squat Cleans

5 Rounds for Time:
– 1 Rope Climb 15 feet
– 4 Hang Squat Cleans @ 60/43 kg

D.  Cool Down

Cool Down
2-3 Rounds:

10 T-Raises

10 Y-Raises

20 Banded Side Steps (Right)

20 Banded Side Steps (Left)

:30sec Couch Stretch (Right)

:30sec Couch Stretch (Left)Scoring: Not Scored

View on WodUp

#### Compare to other Fridays
{: .t60 }

{% include list-posts tag='friday' entries='5' %}

branch_name: refs/heads/gh-pages


text:
Docker Compose/Swarm integration
================================

Eventually, Compose and Swarm aim to have full integration, meaning you can point a Compose app at a Swarm cluster and have it all just work as if you were using a single Docker host.

However, the current extent of integration is minimal: Compose can create containers on a Swarm cluster, but the majority of Compose apps won’t work out of the box unless all containers are scheduled on one host, defeating much of the purpose of using Swarm in the first place.

Still, Compose and Swarm can be useful in a “batch processing” scenario (where a large number of containers need to be spun up and down to do independent computation) or a “shared cluster” scenario (where multiple teams want to deploy apps on a cluster without worrying about where to put them).

A number of things need to happen before full integration is achieved, which are documented below.

Re-deploying containers with `docker-compose up`
------------------------------------------------

Repeated invocations of `docker-compose up` will not work reliably when used against a Swarm cluster because of an under-the-hood design problem; [this will be fixed](https://github.com/docker/fig/pull/972) in the next version of Compose. For now, containers must be completely removed and re-created:

    $ docker-compose kill
    $ docker-compose rm --force
    $ docker-compose up

Links and networking
--------------------

The primary thing stopping multi-container apps from working seamlessly on Swarm is getting them to talk to one another: enabling private communication between containers on different hosts hasn’t been solved in a non-hacky way.

Long-term, networking is [getting overhauled](https://github.com/docker/docker/issues/9983) in such a way that it’ll fit the multi-host model much better. For now, containers on different hosts cannot be linked. In the next version of Compose, linked services will be automatically scheduled on the same host; for now, this must be done manually (see “Co-scheduling containers” below).

`volumes_from` and `net: container`
-----------------------------------

For containers to share volumes or a network namespace, they must be scheduled on the same host - this is, after all, inherent to how both volumes and network namespaces work. In the next version of Compose, this co-scheduling will be automatic whenever `volumes_from` or `net: "container:..."` is specified; for now, containers which share volumes or a network namespace must be co-scheduled manually (see “Co-scheduling containers” below).

Co-scheduling containers
------------------------

For now, containers can be manually scheduled on the same host using Swarm’s [affinity filters](https://github.com/docker/swarm/blob/master/scheduler/filter/README.md#affinity-filter). Here’s a simple example:

```yaml
web:
  image: my-web-image
  links: ["db"]
  environment:
    - "affinity:container==myproject_db_*"
db:
  image: postgres
```

Here, we express an affinity filter on all web containers, saying that each one must run alongside a container whose name begins with `myproject_db_`.

- `myproject` is the common prefix Compose gives to all containers in your project, which is either generated from the name of the current directory or specified with `-p` or the `DOCKER_COMPOSE_PROJECT_NAME` environment variable.
- `*` is a wildcard, which works just like filename wildcards in a Unix shell.

repository: hypriot/compose

branch_name: refs/heads/raspbian

repo_name: hypriot/compose


text:
# Documentation for Neo4j Bolt Driver for JavaScript
The docs are generated with [esdoc](https://github.com/esdoc/esdoc), which is added
as a devDependency to this project.

## Generate docs
Execute in project root.

```
npm install
npm run docs
```

## Read docs
Point your web browser to `docs/build/index.html`.


text:
# azure.monitor

Sample templates for various Azure Monitor components and services

Please refer to the following blog posts for additional details regarding the solutions in that repository:

* [How to audit Azure Hybrid Benefit usage with Azure Workbooks](https://andrewmatveychuk.com/how-to-audit-azure-hybrid-benefit-usage-with-azure-workbooks/)


text:
---
title: October Chess Engine Updates
layout: post
tags: [java, game]
uuid: 438369c7-5406-3133-f427-237674b1e53e
---

When I wrote a [chess engine](/blog/2010/10/17/) a year ago, I left it
in a slightly incomplete state. The original intention was to try out
an old [genetic algorithm idea](/blog/2007/10/24/) of mine, and
creating a chess engine was just a side effect of that. Well, that
didn't work out so well since the vast majority of my engine's games
against itself would end in ties, leaving me with very little data to
work with.

I was left with a working chess engine with some rough edges. Mainly,
there was an "undo move" option that didn't work right, the graphics
could use a little work, and the only way to set the engine's strength
was by editing a text file and injecting it into the classpath.

Six months later it got
[some attention on a chess enthusiast forum](/blog/2011/04/09/). I
gave some advice on how to tweak the engine a bit and it made me
realize how hard that is for many people to do. "Hey, there are some
people actually interested in using my unnamed chess engine. Cool! I
should probably fix some of those rough edges." So I did.

First I gave it a name, since no one on that forum seemed to know what
to call it. Most of the work was done in October of 2010, so I went
with that: **October**. The October Chess Engine. It's also now in the
public domain, no copyrights attached.

Next, since I've learned so much about Java 2D graphics in the last
year, I reworked the graphics. The graphics code is shorter and
simpler, the GUI looks nicer, and it now permits user resizing of the
window. It's also a little larger by default.

I fixed the engine so that it can search an odd number of plies. All
it needed was a a sign change in one place. The hard part was figuring
out where exactly it needed to be done. With that fixed, I modified
the GUI so that the user can select the difficulty setting.

![](/img/chess/difficulty.png)

I've also advanced my knowledge of Java threading, cleaning up thread
management in the engine. There's no difference from a user
perspective, except that it no longer triggers thread-related JVM bugs
— which I've seen occur when rapidly instantiating and tearing down
many threads.

As a side-effect of tidying threading, I made an experimental branch
([`distributed`](https://github.com/skeeto/october-chess-engine/tree/distributed))
that allows the AI to make use of other computers in the network. The
entire board state is serialized, along with a single unevaluated
move, and sent off to other machines. They analyze the move and report
back with the move's score.

While investigating a move can be done independently, it misses out on
a serious optimization. Scores from previous moves can be used to
constrain the current search, allowing the AI to skip over entire
branches of the search tree
([alpha-beta pruning](http://en.wikipedia.org/wiki/Alpha-beta_pruning)).
When all 30-some possible moves are evaluated in parallel, that
optimization is completely lost. As a result, going from one machine
to two equal machines tends to have no real speedups, because
cumulatively they have to work harder than a single machine. It's not
until several machines are added that the optimization loss is
overcome.

Also with the threading change, I added an AI time estimate, so the
user knows how long the AI will take. This is important with the new
difficulty settings, since high difficulties can take awhile to
compute. Sometimes it's wildly off, particularly when the AI only
takes a few seconds, but, to my own surprise, it can be quite accurate
when the AI is taking several minutes to complete its turn. Because of
the previously-mentioned optimization, the AI speeds up as it
progresses, so newer timings are weighted more than older timings.

And finally, one of the most visible changes to the user, I created an
[NSIS installer](http://nsis.sourceforge.net/) for the Windows users
(available in the downloads section of
[October's website](https://github.com/skeeto/october-chess-engine)). They
can click their way through a familiar install wizard, making the
chess engine a neatly-packaged product. I got the idea from
[DCSS](http://crawl.develz.org/wordpress/), which has a very well
organized build system and makes good use of NSIS.

In the future I'd like to tidy up the experimental distributed AI
stuff, possibly rebuild it on top of Java RMI. I'd also like to add
support for the Universal Chess Interface (UCI). That would allow me
to determine an accurate rating for October, and it would give me an
excellent excuse to not do any more GUI work because another GUI could
easily be used in its place.

license: Unlicense

extension: markdown

gha_license_id: Unlicense