text:
# Transloadit Node.js SDK [![Build Status](https://travis-ci.org/transloadit/node-sdk.svg?branch=master)](https://travis-ci.org/transloadit/node-sdk)

A **Node** integration for [Transloadit](https://transloadit.com)'s file
uploading and encoding service.

## Intro

[Transloadit](https://transloadit.com) is a service that helps you handle file
uploads, resize, crop and watermark your images, make GIFs, transcode your
videos, extract thumbnails, generate audio waveforms, and so much more. In
short, [Transloadit](https://transloadit.com) is the Swiss Army Knife for your
files.

This is a **Node** SDK to make it easy to talk to the
[Transloadit](https://transloadit.com) REST API.

## Install

Inside your project, type

```bash
npm install --save --save-exact transloadit
```

If there are no errors, you can start using the module.

## Usage

```javascript
import TransloaditClient from 'transloadit'

const transloadit = new TransloaditClient({
  authKey: 'YOUR_AUTH_KEY',
  authSecret: 'YOUR_AUTH_SECRET'
})

transloadit.addFile('file1', filePath);

const assemblyOptions = {
  params: {
    template_id: 'YOUR_TEMPLATE_ID'
  }
}

transloadit.createAssembly(assemblyOptions, (err, result) => {
  if (err) {
    throw new Error(err)
  }

  console.log('success')

  let assemblyId = result.assembly_id

  console.log({
    assemblyId: assemblyId
  })

  transloadit.deleteAssembly(assemblyId, (err) => {
    console.log('deleted')
  })
})
```

## Example

For fully working examples take a look at
[`examples/`](https://github.com/transloadit/node-sdk/tree/master/examples).

## API

These are the public methods on the `TransloaditClient` object and their descriptions.

### Main

#### constructor([options])

Returns a new instance of the client. The `options` object must at least include `authKey` and `authSecret` keys (and their values).

You can also provide `service`, which defaults to `"api2.transloadit.com"`, and `region`, which defaults to `"us-east-1"`.

By default `TransloaditClient` will use SSL so it will access `service` with a https:// prefix. You can switch this off by providing options.useSsl with a value of `false`.

#### calcSignature(params)

Calculates a signature for the given `params` JSON object. If the `params` object does not include an `authKey` or `expires` keys (and their values) in the `auth` sub-key, then they are set automatically.

This function returns an object with the key `signature` (containing the calculated signature string) and a key `params`, which contains the stringified version of the passed `params` object (including the set expires and authKey keys).

### Assemblies

#### TransloaditClient.addFile(name, path)

Registers the local file with the client. The next call to `createAssembly` will upload that file.

#### TransloaditClient.addStream(name, stream)

Registers the provided stream with the client. The next call to `createAssembly` will upload that stream.

#### TransloaditClient.createAssembly(options, cb)

Creates a new assembly on Transloadit, uploading all streams and files that were registered via `.addStream()` and `.addFile()` prior to the call to `.createAssembly()`.

You can provide some options:

* `params` - an object containing your `template_id`, `notify_url`, some steps that overwrite your Transloadit template and other params to control Transloadit behavior.
* `fields` - an object of form fields to add to the request, to make use of in the assembly via [assembly variables](https://transloadit.com/docs#assembly-variables).

This function (like all functions of this client) automatically obeys all rate limiting imposed by Transloadit. There is no need to write your own
wrapper scripts to handle rate limits.

#### TransloaditClient.lastUsedAssemblyUrl()

Returns the internal url that was used for the last call to `Transloadit.createAssembly()`. This is meant to be used for debugging purposes.

#### TransloaditClient.listAssemblies(params, cb)

Retrieves an array of assemblies according to the given `params`.

Valid params can be page, pagesize, type, fromdate and todate. Please consult the [Transloadit API docs](https://transloadit.com/docs/api-docs/#retrieve-assembly-list) for details.

#### TransloaditClient.streamAssemblies(params)

Creates an objectMode readable stream that automates handling of listAssembly
pagination. It accepts the same params as listAssembly.

This can be used to iterate through assemblies:

```javascript
var assemblyStream = client.streamAssemblies({ fromdate: "2016-08-19 01:15:00 UTC" });

assemblyStream.on("readable", function() {
  var assembly = assemblyStream.read();
  if (assembly == null) console.log("end of stream");

  console.log(assembly.id);
});
```

Results can also be piped. Here's an example using
[through2](https://github.com/rvagg/through2):

```javascript
var assemblyStream = client.streamAssemblies({ fromdate: "2016-08-19 01:15:00 UTC" });

assemblyStream
  .pipe(through.obj(function(chunk, enc, callback) {
    this.push(chunk.id + "\n");
    callback();
  }))
  .pipe(fs.createWriteStream("assemblies.txt");
```

#### TransloaditClient.getAssembly(assemblyId, cb)

Retrieves the JSON status of the assembly identified by the given `assemblyId`.

#### TransloaditClient.deleteAssembly(assemblyId, cb)

Removes the assembly identified by the given `assemblyId` from the memory of the Transloadit machines, ultimately cancelling it. This does not delete the assembly from the database - you can still access it on `https://transloadit.com/assemblies/{assembly_id}` in your Transloadit account. This also does not delete any files associated with the assembly from the Transloadit servers.

#### TransloaditClient.replayAssembly(options, cb)

Replays the assembly identified by the given `assembly_id`. The `options` parameter must contain an `assembly_id` key containing the assembly id. Optionally you can also provide a `notify_url` key if you want to change the notification target.

### Assembly notifications

#### TransloaditClient.replayAssemblyNotification(options, cb)

Replays the notification for the assembly identified by the given `assembly_id`.  The `options` parameter must contain an `assembly_id` key containing the assembly id. Optionally you can also provide a `notify_url` key if you want to change the notification target.

#### TransloaditClient.listAssemblyNotifications(params, cb)

Retrieves an array of assembly notifications according to the given `params`.

Valid params can be `page`, `pagesize`, `type` and `assembly_id`. Please consult the [Transloadit API docs](https://transloadit.com/docs/api-docs/#retrieve-assembly-notification-list) for details.

#### TransloaditClient.streamAssemblyNotifications(params)

Creates an objectMode readable stream like streamAssemblies that automates
handling of listAssemblynotifications pagination.

### Templates

#### TransloaditClient.createTemplate(params, cb)

Creates a template the provided params. The required `params` keys are: name (the template name) and template (the template JSON string).

#### TransloaditClient.editTemplate(templateId, params, cb)

Updates the template represented by the given `templateId` with the new value. The `params` works just like the one from the `createTemplate` call.

#### TransloaditClient.getTemplate(templateId, cb)

Retrieves the name and the template JSON for the template represented by the given templateId.

#### TransloaditClient.deleteTemplate(templateId, cb)

Deletes the template represented by the given templateId on Transloadit.

#### TransloaditClient.listTemplates(params, cb)

Retrieves a list of all your templates from Transloadit. The `params` parameter can contain properties such as `order`, `sort`, and `page`. For a list of all available params please check [this entry](https://transloadit.com/docs/api-docs/#retrieve-template-list) in the Transloadit API docs.

#### TransloaditClient.streamTemplates(params)

Creates an objectMode readable stream like streamAssemblies that automates
handling of listTemplates pagination.

## Contributing

We'd be happy to accept pull requests. If you plan on working on something big, please first drop us a line!

### Building

The SDK is written in ES6, but the ES5 JavaScript it generates is committed back into the repository so people can use this module without a ES6 dependency. If you want to work on the source, please do so in `./src` and type: `npm run build` or `npm run test` (also builds first). Please don't edit generated JavaScript in `./lib`!

### Testing

Check your sources for linting errors via `npm run lint`, and unit tests, and run them via `npm run test`, or `npm run mocha` for faster iterations.

### Releasing

Releasing a new version to npmjs.org can be done via `npm run release:major` (or minor / patch, depending on the [semantic versioning](http://semver.org/) impact of your changes). This will automatically:

 - Bump the version inside the `package.json`
 - Save a release commit with the updated version in Git
 - Push a tag to Github
 - Publish to npmjs.org

### Convenience

If you come from a unix background and fancy faster auto-complete, you'll be delighted to know that all npm scripts are also accessible under `make`, via fakefile.

## Authors

* [Tim Koschützki](https://twitter.com/tim_kos)

Contributions from:

* [Kevin van Zonneveld](https://twitter.com/kvz)
* [Adrian Sinclair](https://github.com/adrusi)
* [Geoff<EMAIL_ADDRESS>* [Jim Gibbs](https://www.linkedin.com/pub/james-gibbs/0/8/4ab)

Thanks to:

* [Ian Hansen](https://github.com/supershabam) for donating the `transloadit` npm name. You can still access his code under `v0.0.0`.

## License

[MIT Licensed](LICENSE).

repository: adrusi/node-sdk

repo_name: adrusi/node-sdk


text:
+++
# Experience widget.
widget = "experience"  # See https://sourcethemes.com/academic/docs/page-builder/
headless = true  # This file represents a page section.
active = true  # Activate this widget? true/false
weight = 40  # Order that this section will appear.

title = "Experience"
subtitle = ""

# Date format for experience
#   Refer to https://sourcethemes.com/academic/docs/customization/#date-format
date_format = "Jan 2006"

# Experiences.
#   Add/remove as many `[[experience]]` blocks below as you like.
#   Required fields are `title`, `company`, and `date_start`.
#   Leave `date_end` empty if it's your current employer.
#   Begin/end multi-line descriptions with 3 quotes `"""`.
[[experience]]
  title = "NLP/AI Scientist"
  company = "Astound.ai"
  company_url = ""
  location = "Menlo Park, CA"
  date_start = "2017-10-01"
  date_end = ""
  description = """
I develop a full suite of Natural Language Processing algorithms, focusing on integrating symbolic and data-driven approaches to push the boundaries and extend the language understanding and cognitive capacities of our domain expert conversational agent.
"""

[[experience]]
  title = "PhD Candidate"
  company = "University of Southern California"
  company_url = ""
  location = "Los Angeles, CA"
  date_start = "2010-08-01"
  date_end = "2017-09-01"
  description = """
PhD in computational neuroscience, under the direction of Dr. Michael Arbib.

Dissertation: Schema architecture for language-vision interactions: a computational cognitive neuroscience model of language use.

Topics:

* modeling language-vision interactions during online comprehension and production of scene descriptions

* design of a new computational construction grammar (Template Construction Grammar)
"""

[[experience]]
  title = "TA for CS 564: Brain Theory and Artificial Intelligence"
  company = "USC Viterbi School of Engineering"
  company_url = ""
  location = "Los Angeles, CA"
  date_start = "2013-01-01"
  date_end = "2015-06-01"
  #description = """ """

[[experience]]
  title = "TA for CS 544: Applied Natural Language Processing"
  company = "USC Viterbi School of Engineering"
  company_url = ""
  location = "Los Angeles, CA"
  date_start = "2013-01-01"
  date_end = "2013-06-01"
  description = """http://www.isi.edu/natural-language/teaching/cs544/"""

+++

license: MIT

repository: victorbarres/academic-kickstart

branch_name: refs/heads/master

extension: md

gha_license_id: MIT

license_type: permissive

repo_name: victorbarres/academic-kickstart


text:
When used for the pipeline, this directory is expected to contain at least the following files:
* `jdkLogConfig.properties`: a JAVA property file allowing to configure logging messages using the package `java.util.logging`
* `log4j.properties`: a JAVA property file allowing to configure logging messages using the library log4j
* `log4j2.xml`: a XML file allowing to configure logging messages using the library log4j2
* a fat JAR of the Bgee pipeline, shipping all its dependencies

The default configuration of `java.util.logging` will be overridden using `jdkLogConfig.properties`.
If you do not want this behavior to take place, use the system property `java.util.logging.config.file` to point to a different configuration file.

The default logging level of the SLF4J SimpleLogger will be set to `error`. Use the system property `org.slf4j.simpleLogger.defaultLogLevel` to change this value.

The configuration of log4j and log4j2 are simply retrieved from the associated configuration files.

This will cover all loggers used by the dependencies of Bgee (SLF4J SimpleLogger, JDK java.util.logging package, log4, log4j2).

### System properties specific to Bgee
* `bgee.dao.jdbc.username`: username to connect to the Bgee database using JDBC
* `bgee.dao.jdbc.password`: password to connect to the Bgee database using JDBC
* `bgee.dao.jdbc.driver.names`: comma-separated list of classnames of the JDBC Driver implementations to use, e.g.: `com.mysql.jdbc.Driver,net.sf.log4jdbc.sql.jdbcapi.DriverSpy`
* `bgee.dao.jdbc.url`: the JDBC connection URL; it should NOT contain the username and password

gha_language: Perl


text:
# aws/cloudtrail - CloudTrail
This module is used to set up CloudTrail logging for your AWS account.

## What this does

 - Create S3 bucket for CloudTrail logs
 - Create IAM user with read-only access to CloudTrail S3 bucket
 - Enable CloudTrail logging

## Required Inputs

- `s3_bucket_name` - The name for the S3 bucket where your CloudTrail logs will be stored

## Optional Inputs

- `cloudtrail_name` - The name for your Trail in AWS CloudTrail. Default: `"aws-account-cloudtrail"`
- `is_multi_region_trail` - Whether the trail is created in the current region or in all regions. Default: `false`

## Outputs

_none_

## Example Usage

```hcl
module "cloudtrail" {
  source          = "github.com/silinternational/terraform-modules//aws/cloudtrail"
  cloudtrail_name = "${var.cloudtrail_name}"
  s3_bucket_name  = "YOUR-AWS-ACCOUNT-cloudtrail-logs"
}
```

repository: silinternational/terraform-modules

branch_name: refs/heads/develop

gha_language: HCL

repo_name: silinternational/terraform-modules


text:
---
layout: page
title: vaquero-plugin-vcoworkflow
permalink: /docs/plugins/vcoworkflow.html
---

The `vaquero-plugin-workflow` plugin leverages a set of workflows in VMware vRealize Orchestrator plus a special template blueprint and corresponding service catalog entry in order to programattically provision your platform via VMware's vCloud IaaS offering.

At this time, this plugin requires a very specific set of workflows to exist, and the entrypoint workflow, `Request Component` is currently under active development and should hopefully see a release on [FlowGrab](https://flowgrab.com) some time soon.

---

Source: [vaquero-plugin-vcoworkflow](https://github.com/vaquero-io/vaquero-plugin-vcoworkflow)

gha_language: CSS


text:
# CIS263_Hashing_Table_Marvel

Zachary Thomas hashing table project using the marvel database for Ira Woodring's CIS 263 class.

Hashing function 1 collisions: 12051

Hashing function 2 collisions: 14077

Hashing function 3 collisions: 5852

### Hashing

We went over hash maps and hashing this past week.  C++ (most languages actually) provides maps in its standard library so there is little reason to ever create our own.  However, the ability to understand how they work and are written is important.

For this project you are tasked with creating a hashmap class.  It can be generic if you like (probably easier to write it that way), or you can write it specifically to house objects of type ```Superhero```.  A ```Superhero``` has the following fields:

```C++
int page_id;
std::string name;
std::string urlslug;
std::string id;
std::string alignment;
char eye_color;
char hair_color;
char sex;
std::string gsm;
boolean alive;
int appearances;
std::string first_appearance;
int year;
```

As per object oriented best practices all fields should be private.

Your hashmap class should hash based on the entire name of the superhero.  You will use the separate chaining method to handle collisions (each array indice will correspond to a vector<Superhero> object where the data will be stored).  Your hashmap will provide only the following public methods:

```C++
boolean insert(const Superhero & s);
Superhero & get(const std::string name);
```

The insert function returns either true or false depending on whether a collision occurred on insert.  Regardless of whether a collision occurred or not the object should be inserted in the vector.  Additionally, as we discussed in class, the object should be added to the front of the vector.

## Hashing Functions

You need to create three different hashing methods.  You may look in your book, online, in journals, etc. to come up with the three hashes, just be sure you document where you found each.

I want us to see how different hashing functions might affect collisions.  To that end, I want you to read in the superhero.csv database file attached below.  You should split each line and create a ```Superhero``` object with it, store it, and keep track of whether a collision occurred.  You should provide a text file in your repository called "RESULTS.md".  This file should contain a copy of your hash function text and the number of collisions that occurred during the course of inserting all superheroes into the hashmap.

## Necessary Files

You should have a ```main.cpp``` file in your ```src``` directory that runs your main code of loading the file, creating an instance of a hashmap, creating objects, and keeping track of the number of collisions.  Your program need do nothing more than print out the number of collisions when complete.

You should have a ```my_hash.h``` file that includes all of your hashmap code.  This file should go in the ```include``` directory.

You should have a ```superhero.h``` in the ```include``` directory that provides the interface for the ```Superhero``` class, and a ```superhero.cpp``` file in ```src``` that provides the implementation.

You will need this database file: [Superheros Database](./marvel-wikia-data.csv "Superhero DB").

## Notes

- You may work with a partner (and probably should).
- Don't go crazy with the hash functions.  Just remember that it must mod based on the table size.
- Start early, and contact me for clarifications.  Also make use of our Slack channel.

## Submission

Turn in a .zip of all your code and files, or a Github link of all files by 8:00 a.m. Wednesday, March 21st.


text:
# react-redux-weatherforecaster

This application uses react library with redux for maintaining application state data and renders weather vitals for 5 day period using Open Weather map API.

Using react-sparkline npm package, the weather is rendered in
graph data format.

The application also integrates with Google MAP API for rendering map data in the view.

### Getting Started

There are two methods for getting started with this repo.

#### Familiar with Git?

```
> git clone https://github.com/rkredux/react-redux-weatherforecaster.git
> npm install
> npm start
```

repository: rkredux/react-redux-weatherforecaster

repo_name: rkredux/react-redux-weatherforecaster


text:
---
layout: page
title: Architecture
in_header: true
permalink: /architecture/
---

Axle generally strives to follow the patterns established
by the [Typelevel](http://typelevel.org/) projects.

With few exceptions, the functions are side-effect free.

The typeclass patterns are drawn from two traditions:
1. [Typeclassopedia](https://wiki.haskell.org/Typeclassopedia)
2. Abstract Algebra

The algorithms are increasingly defined only in terms of these typeclasses.
Concrete runtime implementations will require witnesses that map non-Axle data structures
onto the typeclass methods and laws.
Many such witnesses are provided by Axle for native Scala collections.

Witnesses are also defined for other common jars from the Java and Scala ecosystems.
Read more about these ["spokes"](/spokes/).

The code will soon compile warning-free.

Remaining Design Issues
-----------------------

See the [Road Map](/road_map/) for more details on the timing of upcoming changes.

Please get in touch if you'd like to discuss these or other questions.

### Spark Context Bounds

The biggest outstanding issue is how to deal with Spark's context bounds
on functions like `map`.
In this case, it means that either `Functor`'s map must also take have the context bound,
even though in non-Spark cases it would go unused, or place the context bound in the
witness instantiation site.

Axle has opted for the latter until another solution can be found.
The biggest downside is the introduction of additional type parameters in typeclasses
like `Functor`.

### Matrix dimensions

Dependent types are needed to encode the size of matrices.
You can see the need for them in the multiplicative and additive monoids for matrices (eg jblas).

### Cats and Algebra

When Spire depends on Algebra and Cats, Axle will too.

repository: Tomcruseal/axle

gha_license_id: NOASSERTION

repo_name: Tomcruseal/axle


text:
# Welcome

---

A website for Ruben Garcia that have his blog content and information about his skills and projects

## How this project was built

Bootstrapped with GatsbyJS starter files

## How to view locally

``` shell
# within your terminal,
cd desktop
git clone https://github.com/rubenfrancogarcia/personal-site.git
cd personal-site
npm install
gatsby develop
```

In a browser, go to localhost:8000

---

# See the live site

deployed with Netlify
https://elastic-booth-92a546.netlify.com/

repository: rubenfrancogarcia/personal-site

gha_language: JavaScript

repo_name: rubenfrancogarcia/personal-site


text:
# Integrations

Flier is fully standalone and doesn't need any additional plugins to work. You can however install these nice plugins to enable additional functionality:

## [BountifulAPI](https://www.spigotmc.org/resources/bountifulapi-1-8-1-9-1-10.1394/)

Installing this plugin will remove command messages from the console when displaying titles and will also display ammunition on the action bar instead of the sidebar.

## [PlaceholderAPI](https://www.spigotmc.org/resources/placeholderapi.6245/)

If you have PlaceholderAPI on your server Flier will add a `flier_` placeholder. It consists of arguments separated by dots, for example `%flier_first.second.third%`.

### Game argument: `game`

This argument will display various information about the game. Second argument is the name of the lobby, third is the name of the game, fourth is the index number of the game (there may be more than one game of the same type running). Fifth argument is the type of information you want to display:

* `name` is the name of the game
* `arena` is the name of the arena which is currently hosting the game
* `players` is the amount of players in the game
* `locked` displays whenever the game is Open or Closed for new players

**Example**: `%flier_game.main_lobby.the_deathmatch.0.players%` - displays the amount of players in the first `the_deathmatch` game in the `main_lobby` lobby.

## [BetonQuest](https://www.spigotmc.org/resources/betonquest.2117/)

Flier adds a few conditions and objectives to the BetonQuest plugin so you can create better games. An example use of this is to create a tutorial for player playing Flier for the first time.

### Conditions

#### Activator: `activator`

This condition checks if the specified activator is active for the player. The first argument is the name of the activator. Keep in mind that activators can only be active during the game.

**Example**: `activator hasAmmo`

#### Engine: `flierengine`

This condition checks if the player is accelerating with his engine. There are no additional arguments.

**Example**: `flierengine`

#### Game: `ingame`

This condition checks if the player is in specified game. It will be true even if he's waiting in the waiting room. The first argument is the game's name.

**Example**: `ingame default`

#### Lobby: `inlobby`

This condition checks if the player is in specified lobby. It will be true event if the player was moved to the game. The first argument is the lobby's name.

**Example**: `inlobby default`

### Objectives

#### Join lobby: `joinlobby`

This objective gets completed when the player joins a correct lobby. The first argument is the lobby's name.

**Example**: `joinlobby default`

#### Join game: `joingame`

This objective gets completed when the player joins a correct game. The first argument is the game's name.

**Example**: `joingame default`

#### Respawn: `flierrespawn`

This objective will be completed upon player's respawn in the game. This includes first time spawn when the game is starting.

**Example**: `flierrespawn`

#### Use item: `flieruse`

This objective requires the player to use an item. You can optionally specify which item or usage must be used. For example if you want the player to use a weapon and all your weapons have _shoot_ usage, you can require that usage on any item instead of creating many objectives, one per weapon. The two optional arguments start with `item:` and `usage:` followed by the name of an item/usage. You can use none, one of them or both.

**Example**: `flieruse usage:shoot`
**Example**: `flieruse item:gun usage:reload`

#### Click button: `flierbutton`

This objective will be completed when you click specified button. The first argument is the button's name.

**Example**: `flierbutton fast_class`

#### Kill: `flierkill`

This objective gets completed when you kill specified amount of other players. The first argument is the amount of players to kill. You can additionally specify a list of BetonQuest conditions these players need to meet in order to be accepted (`required:` optional argument) and if you want to target specific player, you can use `name:` optional argument.

**Example**: `flierkill 5 required:flying`

#### Hit: `flierhit`

This objective is essentially the same as `flierkill`, except you need to hit players with your weapon instead of killing them.

**Example**: `flierdeath`

#### Get hit: `fliergethit`

To complete this objective you need to get hit.

**Example**: `fliergethit`

####

## [BetonLangAPI](https://github.com/Co0sh/BetonLangAPI)

This plugin is a language library which allows displaying translated messages based on player's chosen language. It supports MySQL database too, so you can use it to sync multiple server or a website.

Item names, lore, team and class names can be translated into multiple languages by replacing their text with `$something` tags and putting actual text in the _messages.yml_ under `something` keys. Just make sure your tags don't collide with existing messages used by the plugin. An example of an item set (from _sets.yml_ file) which has translated class name:

```
translated_set:
  name: '$className'
  category: main
  [...]
```

And in the _messages.yml_:

```
en:
  className: Fast
  [...]
pl:
  className: Szybki
  [...]
```

repository: Tominous/Flier

repo_name: Tominous/Flier


text:
# @wemake-services/eslint-config-javascript

[![wemake.services](https://img.shields.io/badge/style-wemake.services-green.svg?label=&logo=data%3Aimage%2Fpng%3Bbase64%2CiVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAAABGdBTUEAALGPC%2FxhBQAAAAFzUkdCAK7OHOkAAAAbUExURQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP%2F%2F%2F5TvxDIAAAAIdFJOUwAjRA8xXANAL%2Bv0SAAAADNJREFUGNNjYCAIOJjRBdBFWMkVQeGzcHAwksJnAPPZGOGAASzPzAEHEGVsLExQwE7YswCb7AFZSF3bbAAAAABJRU5ErkJggg%3D%3D)](http://wemake.services)
[![Build Status](https://travis-ci.com/wemake-services/wemake-frontend-styleguide.svg?branch=master)](https://travis-ci.com/wemake-services/wemake-frontend-styleguide)
[![wemake-frontend-styleguide](https://img.shields.io/badge/style-wemake-000000.svg)](https://github.com/wemake-services/wemake-frontend-styleguide)

Shareable configuration for [`eslint`](https://github.com/eslint/eslint).

[![JavaScript Style Guide - Standard Style](https://cdn.rawgit.com/standard/standard/master/badge.svg)](http://standardjs.com)

The main idea of this configuration is to be:

1. Highly opinionated (!)
2. Strict about syntax and secure by default
3. Enforces best-practices

The ultimate goal of this project is to become the strictest config available.

## Installation

```bash
npm install --save-dev @wemake-services/eslint-config-javascript
```

Then, modify your `eslint` configuration:

```json
{
  "extends": [
    "@wemake-services/javascript"
  ]
}
```

Done! Later you can modify your configuration to include
any extra rules you need.

## License

MIT.


text:
Teams API
=========

## Teams

A team object contains the following attributes.

Attribute | Type | Editable | Description
:---------|:-----|----------|------------
`id` | [ID][] | read-only | The unique identifier of this team
`organization_id` | [ID][] | read-only | ID of the organization who owns this team.
`organization` | object | read-only | The [organization][] who owns this team.
`name` | string | **required** | Name of the team. Must be a non-empty string.
`display_name` | string | read-only | Display name of the team. It may equal to the `name` attribute, unless this team is [shared][outgoing team share] to your organization with a custom `share_name`.
`created_at` | [date/time][] | read-only | When the team resource was created
`updated_at` | [date/time][] | read-only | When the team resource was updated last time
`member_count` | integer | read-only | Number of [members][team membership] in this team, including both admins and non-admins. **Available only to your own organization.**
`admin_count` | integer | read-only | Number of [admins][team membership] in this team. **Available only to your own organization.**

### Get a collection of teams
Return a [paginated collection][] of all the [team][] resources of an organization (`<organization_id>`). By default, this also includes any [teams shared to your company][incoming team shares]!

`GET https://service.giosg.com/api/v5/orgs/<organization_id>/teams`

Parameter | Type | Default | Description
----------|------|---------|------------
`ordering` | [ordering][] | `created_at` | Ordering of results with options `created_at` or `-created_at`
`is_shared` | boolean | (none) | If `true`, return only teams that are shared to the organization. If `false`, return only the organization's own teams.

Teams are readable by anyone in the same organization. However, they can be created, updated or deleted only by organization managers.

### Retrieve team details
Get a single team object (`<team_id>`) of an organization (`<organization_id>`). This may be a [team shared to the organization][incoming team shares].

`GET https://service.giosg.com/api/v5/orgs/<organization_id>/teams/<team_id>`

### Creating a team
Create a team for an organization (`<organization_id>`)

`POST https://service.giosg.com/api/v5/orgs/<organization_id>/teams`

### Update a team
You may update the editable attributes of a team (`<team_id>`) that belongs to an organization (`<organization_id>`). You can make either a `PATCH` request (update a subset of attributes) or `POST` request (update all the attributes).

`PUT https://service.giosg.com/api/v5/orgs/<organization_id>/teams/<team_id>`

`PATCH https://service.giosg.com/api/v5/orgs/<organization_id>/teams/<team_id>`

### Delete a team

<aside class="warning">
Deleting a team will immediately clear all the memberships from the team. It will also unshare it from your partners! You cannot undo this action, but you can re-create and re-share the team and its memberships again.
</aside>

You may delete one of your own teams by making a `DELETE` request.

`DELETE https://service.giosg.com/api/v5/orgs/<organization_id>/teams/<team_id>`

## Team memberships

A **team membership** represents a user belonging to a specific team. Team memberships are only visible for teams of your own organization. A team membership resource has the following attributes.

Attribute | Type | Editable | Description
:---------|:-----|----------|------------
`team_id` | [ID][] | read-only | ID of the team to which this member belongs.
`team`| object | read-only | The [team][] to which this member belongs, with attributes `id`, `name`, `display_name`, and `organization_id`.
`user_id` | [ID][] | read-only | ID of the member user.
`user` | object | read-only | The member [user][] resource. Has all other attributes than `organization`
`is_admin` | boolean | **required** | Whether or not the member is an admin of the team.
`created_at` | [date/time][] | read-only | When the membership resource was created
`updated_at` | [date/time][] | read-only | When the membership resource was updated last time

Team memberships are readable by any member of the same organization. However, they can be created, updated or deleted only by either organization managers or by team admins. Otherwise, the endpoints will return a `403 Forbidden` response.

### Get a collection of team members
Return a [paginated collection][] of all the [team membership][] resources for a specific [team][].

`GET https://service.giosg.com/api/v5/orgs/<organization_id>/teams/<team_id>/memberships`

Parameter | Type | Default | Description
----------|------|---------|------------
`is_admin` | boolean | (none) | If `true`, return only admin memberships. If `false`, return only non-admin memberships.

### Add a member to a team
You may add a user of your own organization to one of your teams by creating a team membership object.

`POST https://service.giosg.com/api/v5/orgs/<organization_id>/teams/<team_id>/memberships/<user_id>`

This returns a `201 Created` response if the user with the given ID was successfully added to the team. If the user was already in the team, this updates the `is_admin` attribute and returns `200 OK` response with the existing membership resource.

### Update a team membership
You may update a team membership, i.e. change the admin status of a member either by attempting to create a new membership with `POST` or updating with `PUT`.

`PUT https://service.giosg.com/api/v5/orgs/<organization_id>/teams/<team_id>/memberships/<user_id>`

This returns a `201 Created` response if the user did not belong to team previously but was now added. If the user was already in the team, this updates the attributes and returns `200 OK` response with the existing membership resource.

You may also update a membership with a `PATCH` request, but this will return `404 Not Found` in case the membership did not exist.

### Remove a member from a team
You may remove a user from a team by deleting his/her membership.

`DELETE https://service.giosg.com/api/v5/orgs/<organization_id>/teams/<team_id>/memberships/<user_id>`

### Retrieve team membership details
You may get the a user membership resource in a team:

`GET https://service.giosg.com/api/v5/orgs/<organization_id>/teams/<team_id>/memberships/<user_id>`


text:
# Arctium WoW Core

[![Join Discord](https://img.shields.io/badge/discord-join-7289DA.svg)](https://discord.gg/3wcx5rK) [![Windows build status](https://ci.appveyor.com/api/projects/status/aaoegmcmp5emmom4/branch/master?svg=true)](https://ci.appveyor.com/project/Fabi/project-wow/branch/master) [![Linux Build Status](https://travis-ci.org/Arctium/WoW-Core.svg?branch=master)](https://travis-ci.org/Arctium/WoW-Core)

### What is WoW Core?

Arctium WoW Core is an open source server project for World of Warcraft written in C# (.NET Core).

The current support game version is: **In development**

### Used dependencies
Info about used 3rd party libs/deps: [Dependencies](https://github.com/Arctium/WoW-Core/blob/master/deps/README.md)

### License & Copyright

The WoW-Core source is licensed under the [MIT](https://github.com/Arctium/WoW-Core/blob/master/LICENSE) license.

## Building

### Build Prerequisites
* [.NET Core SDK 2.1.300-rc1 or later](https://www.microsoft.com/net/download/dotnet-core/sdk-2.1.300-rc1)

### Working IDEs (optional)
* Cross Platform: Jetbrains Rider (Build 2018.1 EAP 181.4379.538) EAP or later
* Windows: Visual Studio version 15.7 Preview 2 or later
* macOS: Visual Studio 2017 for Mac version 7.5 Preview 1 (<IP_ADDRESS>3) or later

### Build Instructions
* Coming soon!

## Important Links

- Coming soon!

repository: martindash/WoW-Core

repo_name: martindash/WoW-Core


text:
# **Masternode Tools**

This Github is for the developement of masternode tools.

## Dynamic Tools
This section will be dedicated to dynamic masternode and wallet tools.

#### Dynamic Wallet Backup Tool
With this script you will be able to back up any coin as long as the binary is installed on the system

###### Dynamic Wallet Backup Tool Instructions

Copy the command below and make sure you change the <user> tags to be your system user!

```
cd /usr/local/bin && sudo wget https://raw.githubusercontent.com/joshpetrick/mnTools/master/backupwallet.sh && sudo chmod 755 backupwallet.sh && sudo chown <user>:<user> backupwallet.sh && cd ~
```

Once installed you can run a test:
 * the binary name is required
 * the destination is optional and will create the backup in current dir if not specified

```
backupwallet.sh [binary name] <backup destination>
```

If you would like timely backups you can add it to a cronjob:
 * Ex: lets have Piecoin backup to a backup dir every monday

```
crontab -e
```

append the following at the bottom of the cronjob and then save and close
```
* * * * 1 /usr/local/bin/backupwallet.sh PieCoind /home/user/.PieCoin/Backups/
```

## Coin Specific Tools

#### Chaincoind Tools

This section will be dedicated to chaincoin tools. Masternodes must be on Ubuntu system and must be configured as normal model and not
controller styled model.

###### Chaincoin Masternode Putty Login Status

This tool will update your welcome message so that everytime you login to putty you are greeted to:
  * Your MN Balance
  * Your MN Status
  * Your last mn transactions
    * type of transaction
    * amount
    * time

 ![alt text](https://github.com/joshpetrick/mnTools/blob/master/MNStatustool.PNG)

###### Installing

```
cd /etc/update-motd.d/ && sudo wget https://raw.githubusercontent.com/joshpetrick/mnTools/master/50-mn-count && sudo chmod 755 50-mn-count && run-parts .
```

##### Uninstalling

```
sudo rm /etc/update-motd.d/50-mn-count
```

#### Chaincoin Masternode Auto Transfer

This tool will automatically send (your acccount total - 1001) chc to a defined wallet address

```
cd /usr/local/bin && sudo wget https://raw.githubusercontent.com/joshpetrick/mnTools/master/chcwallettransfer.sh && sudo chmod 755 chcwallettransfer.sh && sudo chown <username>:<username> chcwallettransfer.sh
```

edit your cron
```
crontab -e
```
20 4 * * 4 /usr/local/bin/chcwallettransfer.sh
.
## Referal Coins

Sign up. Listen to music. Earn coins. Make masternodes. Earn coins. Repeat
Bitrad.io

## License

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

## Donations

* Chaincoin ```CX7Vqe8nWDouVnKiBwfvaPGLRCRvunKT6y```
* PieCoin   ```PXWMdAWg7Eym33jKAVyf3ZWLLiCAY5dQu3```
* Bitcoin   ```18kd7yE2ZxbApErrJgWRFqX2sePZDosi95```
* Coinonatx   ```CcCJFXNwAiuhLTDe6earkH2CHJJcX6Rjc3```
* Bitradio   ```Bp8nzXLPAyfzBF9PpPTAcmAyBbwYX158wk```

repository: joshpetrick/mnTools

gha_language: Shell

repo_name: joshpetrick/mnTools


text:
---
layout: post
title:      "Javascript Mod Take 2"
date:       2021-04-10 17:52:07 +0000
permalink:  javascript_mod_take_2
---

So, this is the second time I'm doing this mod. Needless to say, I have actually really learned this time, instead of stressing out over and over and over about if what I am doing is correct - etc.

I decided for this project, I would actually make a game. My other project was fine, but I think I was aiming too high to actually figure out what it was that I was doing. This one is just simple AND it has to do with one of my favorite shows - The Office.

![](https://i.pinimg.com/originals/8a/10/eb/8a10ebcb5d42cca21a69f7fbdd79809c.gif)

I decided that I would make a game organized by difficulty of quote and who said it (graded by 1, 2, or 3). You input your name and enter the high scores if your score gets high enough!

I figure that this would be super fun to do and really simple than just using an API for data; not that using and API was hard or confusing, but because of the fact that I wanted to understand Javascript in a different way than just all the things I'm used to.

So, here's hoping for success in round two! I'm very close to finishing school! Just need to keep trucking!

extension: markdown


text:
# Command Environment

Two examples that show how the
[ephemeral request/response environment](https://realtimelogic.com/ba/doc/?url=lua.html#CMDE)
can be used by included and/or forwarded pages.

![Request/Response Environment](https://realtimelogic.com/ba/doc/en/img/RequestResponseEnv.png "Request/Response Environment")

Run the examples as follows:

```
cd command-env
mako -l::include
mako -l::forward
```

See the [Mako Server command line video tutorial](https://youtu.be/vwQ52ZC5RRg) for more information on how to start the Mako Server.

repository: VAMSHI-CHOULA/LSP-Examples

repo_name: VAMSHI-CHOULA/LSP-Examples


text:
# RSFontSizes

[![CI Status](http://img.shields.io/travis/rootstrap/RSFontSizes.svg?style=flat&colorA=000000)](https://travis-ci.org/rootstrap/RSFontSizes)
[![Carthage compatible](https://img.shields.io/badge/Carthage-compatible-4BC51D.svg?style=flat&colorA=000000)](https://github.com/Carthage/Carthage)
[![Version](https://img.shields.io/cocoapods/v/RSFontSizes.svg?style=flat&colorA=000000)](http://cocoapods.org/pods/RSFontSizes)
[![License](https://img.shields.io/cocoapods/l/RSFontSizes.svg?style=flat&colorA=000000)](http://cocoapods.org/pods/RSFontSizes)
[![Platform](https://img.shields.io/cocoapods/p/RSFontSizes.svg?style=flat&colorA=000000)](http://cocoapods.org/pods/RSFontSizes)

## What is it?

RSFontSize allows you to manage different font sizes for every device screen size in a flexible manner.
- No more family name and styles typing/guessing every time you use a font.
- Flexible size configurations(Fixed, Proportional to screen size and user specific).
- Smart size estimation for vague specifications.
- Save your font configurations for different UIFontTextStyle(.body, .headline, etc).

## Installation

### Cocoapods

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

```ruby
pod "RSFontSizes"
```

### Carthage

1. Add the following sources to your Cartfile:

```
github "rootstrap/RSFontSizes" ~> 1.2.0
```

2. Run the `carthage update` command in the terminal.

3. Link the resulting RSFontSizes.framework and Device.framework to your project.

### Quick peek

From poorly managed font sizes:

![Normal Preview](https://github.com/rootstrap/RSFontSizes/blob/master/fixed-font-sizes.jpg?raw=true)

Fonts are set directly from IB.

To readable texts:

![Preview With RSFontSizes](https://github.com/rootstrap/RSFontSizes/blob/master/dynamic-font-sizes.jpg?raw=true)

Fonts using RSFontSizes.

## Start using RSFontSizes

Just link your font assets to the project. Very detailed guide [here](http://codewithchris.com/common-mistakes-with-adding-custom-fonts-to-your-ios-app/).

If there are too many font files to add, FontBlaster pod is strongly recommended.
It's a simple solution to load your assets automatically instead of manually adding every file to the Info.plist.

### Optionally add shortcuts to your favourite fonts.

```swift
extension Font {
  //Your Custom font family names
  static let raleway = "Raleway".font()!
}
```

## Perks

There are different types to get your fonts correctly sized:

-Fixed: The consumer sets the font point size or uses one of the provided classes(.small, .medium, etc).

```swift
let font = Font.raleway.small
```

No magic here :)

-Proportional: The consumer will specify a base font size asociated with a device screen size.

```swift
let font = Font.raleway.proportional(to: (.screen3_5Inch, 10))
```

The result will be a font resized accordingly for the current device screen size.

-Screen Specific: The consumer defines a set of font sizes linked to an specific screen size.

```swift
let font = Font.raleway.specific(values: [.screen4Inch: 12,
                                          .screen4_7Inch: 13.5,
                                          .screen5_5Inch: 16,
                                          .screen9_7Inch: 20.2]))
```

If a screen size is not specified the library will try to estimate the correct value for the font size.

### You can also...

#### Use a String as the Font family name

```swift
let font = "Raleway".font(withWeight: .bold,
                          size: .fixed(20))
```

#### Save your 'templates' to reuse

```swift
Font.save(font: someFont, forClass: .body)
```

And then use it elsewhere:

```swift
let label.font = Font.with(class: .body)
```

## Example

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

## Credits

**RSFontSizes** is maintained by [Rootstrap](http://www.rootstrap.com) and [German López](https://github.com/glm4) with the help of our [contributors](https://github.com/rootstrap/RSFontSizes/contributors).

## License

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

[<img src="https://s3-us-west-1.amazonaws.com/rootstrap.com/img/rs.png" width="100"/>](http://www.rootstrap.com)

repository: gemicn/RSFontSizes

repo_name: gemicn/RSFontSizes


text:
## 2295. Replace Elements in an Array

You are given a **0-indexed** array ```nums``` that consists of ```n``` **distinct** positive integers. Apply ```m``` operations to this array, where in the ```i```-th operation you replace the number ```operations[i][0]``` with ```operations[i][1]```.

It is guaranteed that in the ```i```-th operation:

* ```operations[i][0]``` **exists** in ```nums```.
* ```operations[i][1]``` does **not** exist in ```nums```.

Return *the array obtained after applying all the operations*.

### Example 1:
```
Input: nums = [1,2,4,6], operations = [[1,3],[4,7],[6,1]]
Output: [3,2,7,1]
Explanation: We perform the following operations on nums:
- Replace the number 1 with 3. nums becomes [3,2,4,6].
- Replace the number 4 with 7. nums becomes [3,2,7,6].
- Replace the number 6 with 1. nums becomes [3,2,7,1].
We return the final array [3,2,7,1].
```
### Example 2:
```
Input: nums = [1,2], operations = [[1,3],[2,1],[3,2]]
Output: [2,1]
Explanation: We perform the following operations to nums:
- Replace the number 1 with 3. nums becomes [3,2].
- Replace the number 2 with 1. nums becomes [3,1].
- Replace the number 3 with 2. nums becomes [2,1].
We return the array [2,1].
```

### Constraints:

* ```n == nums.length```
* ```m == operations.length```
* ```1 <= n, m <= 10^5```
* All the values of ```nums``` are **distinct**.
* ```operations[i].length == 2```
* ```1 <= nums[i], operations[i][0], operations[i][1] <= 10^6```
* ```operations[i][0]``` will exist in ```nums``` when applying the ```i```-th operation.
* ```operations[i][1]``` will not exist in ```nums``` when applying the ```i```-th operation.

repository: stdstring/leetcode

repo_name: stdstring/leetcode


text:
# va-starter
Pre-req for building Virtual Agent

## Installation Guide

Please follow below instructions.

  1. Open Command Line Interface
  2. Run the command 'curl -o installer.bat https://raw.githubusercontent.com/balaji-munusamy/va-starter/main/installer.bat'
  3. Run the command 'installer.bat'

repository: balaji-munusamy/va-starter

branch_name: refs/heads/main

repo_name: balaji-munusamy/va-starter


text:
# Peanut Cucumber Chicken Satay

## Ingredients

- 4 - each, Chicken Breast, Tyson 4oz, IQF raw 04316 Cut into 3/4 inch Cubes

- 5 - tbsp, Soy sauce made from soy and wheat (shoyu), low sodium

- 4 1/4 - tbsp, Cornstarch

- 2 - clove, Garlic, raw Minced

- 1 - oz, Ginger root, raw Minced

- 1 - cucumber (8-1/4"), Cucumber, with peel, raw Cut into ½” Pieces

- 2 - tablespoon, Oil, corn, peanut, and olive

- 3/4 - small, Onions, raw Finely Chopped

- 1 - clove, Garlic, raw Minced

- 2 - 2 tbsp, Peanut butter, chunk style, with salt

- 2 - fl oz, Water, tap, drinking

- 1 - 2 oz , Thai Cucumber Relish

- 1/4 - cup, Seeds, sesame seeds, whole, dried

## Method

### Chicken

1. Preheat oven to 350F
---

2. Place chicken into a non reactive dish, then add soysauce, cornstarch, ginger and garlic, mix together well. Cover and allow to marinate in the refigerator for at least 4 hours.
---

3. Equally divide the cubed chicken among 12 bamboo skewers that were soaked in cold water for 45-60 min. Crust chicken skewers in black and white sesame seeds.
---

4. Transfer skewers to a baking sheet, bake for 6-8 min. or until cooked through.
---

### Sauce

5. In a saucepan over medium heat, heat oil and then add onion and garlic. Cook until soffened, stirring frequently.
---

6. Add peanut butter and water and let simmer for 2 min.
---

### Serve

Serve 3-skewers and 2.5 oz of cucumber with 2 oz of peanut sauce.

repository: troyerta/recipes

gha_language: Python

repo_name: troyerta/recipes


text:
LaTeX Homework Boilerplate
===========================
A LaTeX boilerplate for academic homework and assignments.

## Building The Document
[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Farkokoley%2Flatex-homework-boilerplate.svg?type=shield)](https://app.fossa.io/projects/git%2Bgithub.com%2Farkokoley%2Flatex-homework-boilerplate?ref=badge_shield)

**Compile to PDF**

`$ make pdf`

This runs [*pdflatex*, *bibtex*, *pdflatex*, *pdflatex*], a command that is
run by default in most graphical LaTex editors.

**Clean temporary files**

`$ make clean`

## Issues

Issues or new features can be reported via the GitHub issue tracker. Please make sure your issue or feature has not yet been reported by anyone else before submitting a new one.

## License

LaTeX Homework Boilerplate is open-sourced software licensed under the [MIT license](LICENSE).

[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Farkokoley%2Flatex-homework-boilerplate.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Farkokoley%2Flatex-homework-boilerplate?ref=badge_large)


text:
# Haplocarpon musivum (Körb.) Vezda SPECIES

#### Status
SYNONYM

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

#### Published in
Lichenes Selecti Exsiccati (Pruhonice) 52(No. 1281): 5 (1975)

#### Original name
Lecidea musiva Körb.

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Ascomycota/Lecanoromycetes/Lecanorales/Lecideaceae/Porpidia/Porpidia musiva/ Syn. Haplocarpon musivum/README.md

repo_name: mdoering/backbone


text:
# nwsradar

Custom component for NWS radar loops for Home Assistant.

<img src="https://github.com/MatthewFlamm/nws_radar/blob/master/images/radar.gif?raw=True" width="400px">

See [README](README.md) for more info on configuration and usage.

## Change log
* 0.5.1
  * Use standard homeassistant method for updating data
* 0.5.0
  * Use UI configuration
  * DEPRECATION: YAML configuration to be removed in 0.6.0
* 0.4.0
  * Add Mosaic style option
* 0.3.0
  * Add Standard style option
  * BREAKING CHANGE: Default is now Standard style

repository: MatthewFlamm/nwsradar

repo_name: MatthewFlamm/nwsradar


text:
# scheduler
simple tool to help in scheduling events

Install the following

* node.js
* angular
* express.js
* mysql backend

* Open mysql and and run script under folder sqlscripts

* make sure to create a user: scheduler pwd:dasscheduler or change config references to your own user

* clone this repo locally

* open a node command console and traverse to folder scheduler. at root scheduler folder run
   npm install

* then run
   node server.js

* open a node command console. go to path scheduler node app/services/api.js
    this will run the API

* install live-server
    npm install live-server

    from scheduler\app folder run live-server

Work in Progress

TODO

    use one config file                                             done
    prevents folder traversal when landing on localhost:8000
    solidify routing

GOTCHAS
    MySQL at times would wig out with time outs. See the following article on how to manage connection pooling etc
    https://codeforgeek.com/2015/01/nodejs-mysql-tutorial/

repository: yosiasz/scheduler

repo_name: yosiasz/scheduler


text:
soa-testing-framework
=====================

Framework for automated testing of Oracle OSB and SOA applications

Description and idea:
Altough there already exists 2 well known testing frameworks to me, Citrus and Robot and both are great and robust, they didn't looked to me so easy to use as soon as I am focused purelly now on just Oracle Service Bus automated testing.
One of the perspectives is also to use that framework by less technical focused people like testers itself. For this approach I selected transformation of Oracle Service Bus into Maven projects, so I can easily use SoapUI maven plugin and create test cases as groovy scripts. This framework should be then called by these groovy template scripts and should be as easy as possible to use by non-developers (another step will be web-based configuration).

I understand that this way is less generic to apply to other systems, but that is its main purpose.

Supported document generation functions:
* Generate CRUD SQL scripts for tasks based on database connection and object (table/view) - currently supported only 1 object.
* Generate default SOAP Envelope for Proxy and Business services from end point URI (WSDL)
* Generate default JMS message based on XML schema (XSD only)

Supported endpoint connection types:
* HTTP SOAP Services
* JDBC - focused on Orale Database
* JMS Server - currently only queue supported (even DISTRIBUTED ones)
* FTP Server
* File System

Supported OSB Functionality:
* Enable/Disable Proxy or Business services in flow to support stop temporarily their functionalities for testing purposes

Main test definition user interface:
* XML configuration file for framework which includes mainly general settings and end point connection information
* SoapUI for configuring the TestCase steps via Groovy templates created for specific operations - I am starting with one scenario and will extend the number, but this should be free to configure based on the user knowledge of the framework.

DEMO Scenario Flow:

Database Source -> Proxy DB Adapter Pooling Service -> Business JMS Service -> JMS Server Queue -> Proxy JMS Pooling Service -> Database DB Adapter Service -> Database Target

Testing Scenario Steps:
Manual:

1. User will configure XML end point connection XML file so framework will be able to communicate with necessary points:
	* "Database Source"
	* "JMS Server Queue"
	* "Database Target"
2. User will use command line or GUI(in future version) tool to generate default SQL DML script - insert in this case - and will be able to customize it before the test exectuion.
Automatic executed by the soap-ui maven plugin (Groovy script templates in place):
1. Disable "Proxy JMS Pooling Service" so any incoming JMS message will stay in queue.
2. Insert row into "Database Source"
3. Delay
4. Check JMS Server Queue for new message
5. If message exists -> Validate it against defined schema
6. Map DB columns to XSD elements - currently it is 1:1 flat mapping where DB column looks like MESSAGE_ID and XML element as messageId, so the mapping is done by processor and is hardcoded (This functionality will be extended in the future by provide mapping file).
7. Check if the values in the DB corespons to the values included in the message.
8. If yes, everything looks good and the test result is OK.
9. Generate report of the test result in PDF or HTML form.
10. Enable "Proxy JMS Pooling Service" so the generated test message can continue in its flow.
11. ...... and so on ....

NOTE: Enabling and Disabling the services is important functionality which can help for example in Pre-Production environments test when sometimes you need to block last service in flow to store the message in the final storage (DB, File, FTP, JMS, whatever it is.)

Ladislav

license: Unlicense

repository: archenroot/soa-testing-framework

gha_language: HTML

repo_name: archenroot/soa-testing-framework


text:
# ChangeLog

## v1.0.0 - 2023-06-20

### Enhancements:

* esp_lcd_panel_io_3wire_spi:
    * Support bit-banging the 3-wire SPI LCD protocol (without D/C and MISO lines)
    * Support for GPIO and IO expander
    * Support for 8-bit/16-bit/24-bit/32-bit data write (without D/C bit)
    * Support for 9-bit/17-bit/25-bit/33-bit data write (including D/C bit)

repository: espressif/esp-iot-solution

gha_language: C

repo_name: espressif/esp-iot-solution


text:
title: Outlook 2003 + iCal.
slug: outlook-2003-ical
date: 2006-02-07 04:32:12+00:00

I was trying today to get Outlook 2003 to accept an iCal feed (which turned out to be horribly out-of-date), but never mind. Dropping the file onto Outlook imported the first item in it, importing it using the Import wizard seemed to work, but this still wasn't quite what I wanted, the idea was to "subscribe" to the calendar feed.

The trick is to use Remote Calendars, worked straight away.

Thanks Alex, and 'Matt'.

repository: FauxFaux/blog

repo_name: FauxFaux/blog


text:
---
title: Webfrontend
layout: config
menu:
  main:
    name: "Webfrontend"
    identifier: "sysadmin/konfiguration/easydb-server.yml/config_webfrontend"
    parent: "sysadmin/konfiguration/easydb-server.yml"
easydb-server.yml:
  - default_client.debug
  - default_client.tag_icons
  - default_client.tag_colors
  - default_client.asset_browser_max_preview_filesize
  - default_client.video_player_use_original
  - default_client.audio_player_use_original
  - default_client.webdvd_player_open_window_parameter
  - default_client.print_limit
  - default_client.collection_refresh_rate_seconds
  - default_client.suggest_disable
  - default_client.database.level
  - default_client.database.server
  - default_client.database.uid
  - default_client.database.instance
  - default_client.download_zip.url
  - default_client.index_html_head_include
  - default_client.index_html_body_include
---

# Webfrontend

This article describes the configuration for the webfrontend which can be done in the server. All configuration for the webfrontend are inside a **default_client** map.

## default_client

The following table describes each key in the map.

| Config                                  | Format  | Description                                                  | Default |
| -------                                 | ------- | ------------------------------------------------------------ | ------- |
| `asset_browser_max_preview_filesize`    | Integer | Up to this size, preview images for the display in the asset browser are considered. If not set to *`-1`*, the *Original* is never taken into account. If set to *`0`*, all sizes and the original are taken into account | - |
| `audio_player_use_original`             | Boolean | If set, the audio player also uses the original as source for the HTML5 audio tag. | *false* |
| `collection_refresh_rate_seconds`       | Integer | Number of seconds waited until the fixed searches in the Finder are updated. | *30* |
| `database`                              |         | | |
|  `instance`                       | String  | Optional overwrite to the the identifier for the storage client on Fylr. If not set, the instance name of **easydb** is used. | - |
|  `level`                          | String  | Overwrites the highest permitted database rights level. Allowed values are: *development*, *commit*, *current*. | - |
|  `server`                         | Url     | Url of the [**Fylr** server](/en/sysadmin/konfiguration/fylr.yml/) to store a common datamodel among multiple **easydb** servers. | - |
|  `uid`                            | String  | UID of the Fylr storage. | - |
| `debug`                                 | Boolean | If set, the client is in debug mode, i.e. there are dump options in the context menu. | *false* |
| `download_zip`                          |         | | |
|  `url`                            | String  | Url of the [**Fylr** server](/en/sysadmin/konfiguration/fylr.yml/) ending in /zip to support ZIP downloads for certain customer solutions. | - |
| `index_html_body_include`               | File    | Name of HTML file to be included in `body` part of `index.html`. It is recommended to put this file into the `config` directory next to the configuration files and reference it from the configuration using the `/config` prefix, e.g. `/config/include_body.html`.| - |
| `index_html_head_include`               | File    | Name of HTML file to be included in `head` part of `index.html`. See `index_html_body_include` for additional notes.| - |
| `print_limit`                           | Integer | Limit the maximum number of objects that can be printed. | *250* |
| `suggest_disable`                       | Boolean | If set, suggestions in input fields are disabled | *false* |
| `tag_colors`                            | String  | Comma-separated list. Color clases for the tags. | *green, red, blue, yellow* |
| `tag_icons`                             | String  | Comma-separated trick. Icon names for tag icons that can be stored for tags. Font-Awesome and CUI designations are allowed | *bolt, check, cloud, warning, legal* |
| `video_player_use_original`             | Boolean | If set, the video player also uses the original as source for the HTML5 video tag. | *false* |
| `webdvd_player_open_window_parameter`   | String  | HTML compliant string for [window.open](https://developer.mozilla.org/en-US/docs/Web/API/Window/open). Settings for opening the new browser window to play a web DVD | - |

repository: yorickreum/easydb-documentation

repo_name: yorickreum/easydb-documentation


text:
# Luma Technical Interview

## Problem Definition

A busy hospital has a list of patients waiting to see a doctor. The waitlist is created sequentially (e.g. patients are added in a fifo order) from the time the patient calls.  Once there is an availability, the front desk calls each patient to offer the appointment in the order they were added to the waitlist. The staff member from the front desk has noticed that she wastes a lot of time trying to find a patient from the waitlist since they're often not available, don't pick up the phone, etc.  She would like to generate a better list that will increase her chances of finding a patient in the first few calls.

## Interview Task

Given patient demographics and behavioral data (see sample-data/patients.json), create an algorithm that will process a set of historical patient data and compute a score for each patient that (1 as the lowest, 10 as the highest) that represents the chance of a patient accepting the offer off the waitlist. Take in consideration that patients who have little behavior data should be randomly added to the top list as to give them a chance to be selected. Expose an api that takes a facility's location as input and returns an ordered list of 10 patients who will most likely accept the appointment offer.

## Weighting Categories

Demographic

- age  (weighted 10%)
- distance to practice (weighted 10%)

Behavior

- number of accepted offers (weighted 30%)
- number of cancelled offers (weighted 30%)
- reply time (how long it took for patients to reply) (weighted 20%)

## Patient Model

- ID
- Age (in years)
- location
  - Lat
  - long
- acceptedOffers (integer)
- canceledOffers (integer)
- averageReplyTime (integer, in seconds)

## Deliverables

The code should be written as a Node.js as a library that anyone can import and use. It should contain documentation and unit tests that show your understanding of the problem. Once you're finished, submit a PR to this repo.

## Solution
### Objective:
Patients priority filter based on the demographic and historical data.
An algorithm that will process a set of historical patient data and compute a score for each patient that (1 as the lowest, 10 as the highest) with weighting category.

The patient score is the aggregate of all scores:
  patientScore = (ageScore*10 + distanceScore*10 + acceptedOffersScore*30 + cancelledOffersScore*30 + averageReplyTimeScore*20) / 100;

Where the score of each property is:
#### 1. Age Score
I assume the older the patient will get higher priority.
  // age n=21 is the lowest (score=1)
  // age m=90 is the highest (score=10)

#### 2. Distance Score
I assume the closer of the patient location to the facility will get higher priority.
  // distance n=>10 miles is the lowest (score=1)
  // distance m=0 mile is the highest (score=10)

#### 3. Accepted Offers Score
I assume the more of the patient accepted offers will get higher priority.
  // acceptedOffers n=0 is the lowest (score=1)
  // acceptedOffers m=100 is the highest (score=10)

#### 4. Cancelled Offers Score
I assume the less of the patient patient cancelled offers will get higher priority.
  // canceledOffers n=100 is the lowest (score=1)
  // canceledOffers m=0 is the highest (score=10)

#### 5. Average Reply Time Score
I assume the quicker the patient replied will get higher priority.
  // averageReplyTime n=1 is the highest (score=10)
  // averageReplyTime m=3600 is the lowest (score=1)

Once a set of patients have been scored, then it will take the top 10.

### Patients with low number of historical data
> Take in consideration that patients who have little behavior data should be randomly added to the top list as to give them a chance to be selected.

I made an assumption that a patient that has low number of accepted offers, cancelled offers, and average reply time falls into this criteria. I made an arbitrary threshold that is 5 for number of accepted offers and cancelled offers. While the threshold for average reply time is 300 (5 minutes).
Then I put them into **the top 3 spots** (sorted by patient scores as well).

## Project Structure
The root directory is meant to be a MEAN application (MongoDB-ExpressJS-Angular4-NodeJS). But the MongoDB and data access layer are not implemented yet.

Usage:
```shell
$ npm install
$ npm run server

><EMAIL_ADDRESS>server /home/ryan/Documents/workspaces/workspace_nodejs/luma-priority
> node server.js

API is running on port 3000
```

Open Angular app at [http://localhost:3000](http://localhost:3000) and api at [http://localhost:3000/api/v1](http://localhost:3000/api/v1).

### luma-priority library (folder `lib/`)
This is the heart of the solution. It is implemented as an npm library and can be published to the npm repository.
I used the TDD (Test Driven Development) methodology. The set of unit tests were written in `lib/test/index.js`, then implementations were coded in `lib/index.js` to pass the tests.

Run the unit tests:
```bash
/workspaces/luma-priority$ cd lib/
/workspaces/luma-priority/lib$ npm install

# Run mocha
/workspaces/luma-priority$ ./node_modules/mocha/bin/mocha

# or use the 'npm' command
/workspaces/luma-priority/lib$ npm test

><EMAIL_ADDRESS>test /workspaces/workspace_nodejs/luma-priority/lib
> mocha --reporter spec

  #luma_priority
    ✓ ping
    ✓ distance in mile

  #scoring Age
    ✓ age 21 is the lowest (score=1)
    ✓ age 90 is the highest (score=10)
    ✓ age 28 is (score=2)

  #scoring AcceptedOffers
    ✓ acceptedOffers 0 is the lowest (score=1)
    ✓ acceptedOffers 100 is the highest (score=10)
    ✓ acceptedOffers 11 is (score=2)

  #scoring CanceledOffers
    ✓ canceledOffers 0 is the highest (score=10)
    ✓ canceledOffers 100 is the lowest (score=1)
    ✓ canceledOffers 11 is (score=9)

  #scoring AverageReplyTime
    ✓ averageReplyTime 3600 is the lowest (score=1)
    ✓ averageReplyTime 1 is the highest (score=10)
    ✓ averageReplyTime 361 is (score=9)

  #scoring Distance
    ✓ distance 0 mile is the highest (score=10)
    ✓ canceledOffers 10 miles is the lowest (score=1)
    ✓ canceledOffers 11 miles is (score=1)

  #scoring Patient
    ✓ patient with the highest (score=10)
    ✓ patient with the lowest (score=1)

  #low historical data
    ✓ patient with low historical data
    ✓ patient without low historical data

  #top 10 patients by patient score
    ✓ patients in order
    ✓ filter patients into ordered patients and low historical data ones

  23 passing (24ms)
```

### API (folder `server/`)
Get the collection of API calls from
[postman collection](https://www.getpostman.com/collections/940e12a2ffa1d16882a9).

The API is also available at [https://luma-priority.herokuapp.com/api/v1](https://luma-priority.herokuapp.com/api/v1)

#### 1. Populate the patients data
Upload the `lib/test/patients.json` file (it was generated with faker.js):
```bash
$ curl -X POST \
  http://localhost:3000/api/v1/patients/upload \
  -H 'content-type: multipart/form-data; boundary=----WebKitFormBoundary7MA4YWxkTrZu0gW' \
  -F<EMAIL_ADDRESS>```

#### 2.  Check the patient scores
Paste the list of patients to the "patients" array:
```bash
curl -X POST \
  http://localhost:3000/api/v1/patients/checkScores \
  -H 'Cache-Control: no-cache' \
  -H 'Content-Type: application/json' \
  -H 'Postman-Token: 8a427588-e942-af39-d8dd-44c2f82739ff' \
  -d '{
	"facilityLocation": {
	    "latitude": "46.7110",
	    "longitude": "-63.1150"
	},
	"patients": [...]
}'
```

### UI (folder `src/`)
  UI is not developed yet.

### VSCode Debugger
![NPM Debug](./docs/NPM%20Debug.jpg)

## Enhancement Recommendations
### 1. Setting configuration.
The luma-priority library needs configuration file in order to optimize the settings.

### 2. CI/CD pipeline.
To make it production ready, it requires Continuous Integration/Continuous Development pipeline.

### 3. Persistence layer.
This is only a prototype. The production data should be managed in database.

## git config
```bash
$ git remote -v
heroku	https://git.heroku.com/luma-priority.git (fetch)
heroku	https://git.heroku.com/luma-priority.git (push)
origin	https://github.com/lumahealthhq/luma-priority.git (fetch)
origin	https://github.com/lumahealthhq/luma-priority.git (push)
```

repository: rwibawa/luma-priority

repo_name: rwibawa/luma-priority


text:
# The Sound System

![Speaker](./public/favicon.ico)

[![Gitpod ready-to-code](https://img.shields.io/badge/Gitpod-ready--to--code-908a85?logo=gitpod)](https://gitpod.io/from-referrer/)

This is a [Next.js](https://nextjs.org/) project bootstrapped with [`create-next-app`](https://github.com/vercel/next.js/tree/canary/packages/create-next-app).

## Getting Started

First, run the development server:

```bash
yarn dev
```

Open [http://localhost:3000](http://localhost:3000) with your browser to see the result.

repository: philals/nextjs-the-sound-system

repo_name: philals/nextjs-the-sound-system


text:
# webspeedtestanalysis

This is the code for analyzing traffic of web-based speedtest platforms. To run this code, please use the following command:

```
go run webspanalysis.go
```
In webspanalysis.go, "datapath" should be changed to the local path where webspeedtest data are stored.
The file structure should be in the form of: $datapath/$node/$platform, where $node is the vm name for running the experiments and $platform is the webspeedtest application name (e.g., ookla, speedtest).

Additionally there are some variables which could be changed. When "toverify" is set to True, this program will automatically verify how accurate the algorithm is (only meaningful when the packets are fully captured.)
When "cleanrun" is enabled, all former running results in the same directory are deleted.

repository: bipulkkuri/webtestkit

repo_name: bipulkkuri/webtestkit


text:
## ZMK Firmware adapted for duckboard/nice!nano combo

Last Updated: 2 Jan 2021

**_warning:_** this is beta firmware, some features may have bugs

Please message me on [discord](https://discord.gg/K3SJrtN5PJ) if you find any bugs

Credit for the ZMK Firmware to [The ZMK Contributors](https://zmkfirmware.dev/)
Hardware credit for the duckboard to [doodboard](https://doodboard.xyz/)
Hardware credit for the nice!nano to Nicell of [nice keyboards](https://nicekeyboards.com/)
Developed with the help of [Hector Barnett](https://discordapp.com/users/305794398476828674)

Join the [ZMK Discord Server](https://zmkfirmware.dev/community/discord/invite) and the [doodboard Discord Server](https://discord.gg/UCEnxWk)

Flashing Instructions:
* download the duckboard.uf2 file
* connect the nice!nano to your computer and put it in bootloader (short gnd+rst twice)
* the nano should appear as a storage device on your computer once in bootloader mode
* drag the duck.uf2 file into the nano storage and it should flash automatically

further flashing instructions in the [nice!nano docs](https://docs.nicekeyboards.com/#/nice!nano/getting_started?id=flashing-firmware-and-bootloaders)

*Default Layout:*

| Layer 0 (Default) | Layer 1 (Function) | Layer 2 (RGB and BT) |
  ------  | ------ | ------
 ![](img/layer0.JPG) | ![](img/layer1.JPG) | ![](img/layer2.JPG)

repository: aidancgray/zmk

repo_name: aidancgray/zmk


text:
# Codecs

## Mappings

The `Mapping[L, H]` trait defines a bi-directional mapping between values of type `L` and values of type `H`.

Low-level values of type `L` can be **decoded** to a higher-level value of type `H`. The decoding can fail; this is
represented by a result of type `DecodeResult.Failure`. Failures might occur due to format errors, wrong arity, exceptions,
or validation errors. Validators can be added through the `validate` method.

High-level values of type `H` can be **encoded** as a low-level value of type `L`.

Mappings can be chained using one of the `map` functions.

## Codecs

A `Codec[L, H, CF]` is a `Mapping[L, H]`, with additional meta-data: an optional schema and the format of the
low-level value (more on that below).

There are built-in codecs for most common types such as `String`, `Int` etc. Codecs are usually defined as implicit
values and resolved implicitly when they are referenced. However, they can also be provided explicitly as needed.

For example, a `query[Int]("quantity")` specifies an input parameter which corresponds to the `quantity` query
parameter and will be mapped as an `Int`. There's an implicit `Codec[List[String], Int, TextPlain]` value that is
referenced by the `query` method (which is defined in the `sttp.tapir` package).

In this example, the low-level value is a `List[String]`, as a given query parameter can be absent, have a single or
many values. The high-level value is an `Int`. The codec will verify that there's a single query paramater with the
given name, and parse it as an int. If any of this fails, a failure will be reported.

In a server setting, if the value cannot be parsed as an int, a decoding failure is reported, and the endpoint
won't match the request, or a `400 Bad Request` response is returned (depending on configuration).

As each codec is also a `Mapping`, codecs can be used to map endpoint inputs and outputs. In such cases, the
additional meta-data (schema & format) isn't taken into account.

## Optional and multiple parameters

Some inputs/outputs allow optional, or multiple parameters:

* path segments are always required
* query and header values can be optional or multiple (repeated query parameters/headers)
* bodies can be optional, but not multiple

In general, optional parameters are represented as `Option` values, and multiple parameters as `List` values.
For example, `header[Option[String]]("X-Auth-Token")` describes an optional header. An input described as
`query[List[String]]("color")` allows multiple occurrences of the `color` query parameter, with all values gathered
into a list.

## Schemas

A codec contains an optional schema, which describes how the high-level value is encoded when sent over the network.
This schema information is used when generating documentation.

Schemas consists of the schema type, which is one of the values defined in `SchemaType`, such as `SString`,
`SBinary`, `SArray` or `SProduct` (for objects). Moreover, a schema contains meta-data: value optionality,
description and low-level format.

For primitive types, the schema values are built-in, and defined in the `Schema` companion object.

The schema is left unchanged when mapping a codec or an input/output, as the underlying representation of the value
doesn't change. However, schemas can be changed for individual inputs/outputs using the `.schema(Schema)` method.

When codecs are derived for complex types, e.g. for json mapping, schemas are looked up through implicit
`Schema[T]` values. See [custom types](customtypes.md) for more details.

## Codec format

Codecs contain an additional type parameter, which specifies the codec format. Each format corresponds to a media type,
which describes the low-level format of the raw value (to which the codec encodes). Some built-in formats include
`text/plain`, `application/json` and `multipart/form-data`. Custom formats can be added by creating an
implementation of the `sttp.tapir.CodecFormat` trait.

Thanks to codecs being parametrised by codec formats, it is possible to have a `Codec[String, MyCaseClass, TextPlain]` which
specifies how to serialize a case class to plain text, and a different `Codec[String, MyCaseClass, Json]`, which specifies
how to serialize a case class to json. Both can be implicitly available without implicit resolution conflicts.

Different codec formats can be used in different contexts. When defining a path, query or header parameter, only a codec
with the `TextPlain` media type can be used. However, for bodies, any media types is allowed. For example, the
input/output described by `jsonBody[T]` requires a json codec.

## Next

Read on about [custom types](customtypes.md).

repository: esthomw/tapir

repo_name: esthomw/tapir


text:
# DevSum 2019 in Stockholm, Sweden

My code samples for the DevSum 2019 conference in Stockholm, Sweden.

## Taking Advantage of AI easily with Azure Cognitive Services

**Abstract:** Data Science and Artificial Intelligence are fascinating areas of computing. Microsoft is betting a lot on these new technologies, but we are also aware that data scientists are highly trained professionals, and that not every software developer can create and maintain complex data models, perform linear algebra or purchase expensive GPU rigs to run these models. This is exactly why we created Cognitive services. This suite of services offers pre-trained models that you can use out-of-the-box to perform operations in Vision, Speech, Knowledge, Search and Language. In this session, Laurent Bugnion, a Cloud Developer Advocate with Microsoft will show you how you can use cognitive services to enhance your applications with advanced capabilities, how you can refine the trained models with your own data and how you can integrate Cognitive Services with other Azure services to automate tasks.

You can see the details and the slides here:
https://galasoft.ch/presentations/details/2019013

See also:

- [More custom vision examples](http://github.com/lbugnion/sample-azure-cognitive1)

- [Cross platform custom vision with Xamarin](http://github.com/lbugnion/sample-crossplatform-customvision)


text:
---
layout: default
---

# 1997-06-24 - Re: Comparing Cryptographic Key Sizes

## Header Data

From: Adam Back<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 0ca1e66f095e9527ca7730f3ec6abec3b6883943d0fe9918d5a6c08fbbc07c8b

Message ID<EMAIL_ADDRESS>Reply To: \<199706241351.OAA04279@hermes\>

UTC Datetime: 1997-06-24 15:09:05 UTC

Raw Date: Tue, 24 Jun 1997 23:09:05 +0800

## Raw message

```
{% raw  %}From: Adam Back<EMAIL_ADDRESS>Date: Tue, 24 Jun 1997 23:09:05 +0800
To<EMAIL_ADDRESS>Subject: Re: Comparing Cryptographic Key Sizes
In-Reply-To: <199706241351.OAA04279@hermes>
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Peter Trei<EMAIL_ADDRESS>writes:
> Adam Back<EMAIL_ADDRESS>writes.
> > 56 bit DES is probably roughly similar to 512 bit RSA in hardness to
> > break.
>
> This is way off. We used ~457,000 MIPS years to search half of the
> DES keyspace. Factoring a 512 bit modulus using the General Number
> Field Sieve (GNFS) would take about 28,000 MIPS years (see Schneier
> for the exact number - I don't have AC2 at hand)
>
> Lenstra has estimated that with 500,000 MIPS years, you should be
> able to factor a 600 bit modulus using GNFS, if your workstations
> had enough memory.

Ah yes.  Well I did read your post on coderpunks where you described
the results of asking Lenstra and looking for ideas for what to break
next, how hard 512 bits was etc.

So... 28,000 MIPs years you say... but that neglects memory.
Lenstra's conclusion was that even 512 bits couldn't be done, from
your post.  So by that measure it is harder (due to memory overhead)
than DES even though theoretically taking less MIPS with 64 mb
workstations.  Also he was unsure about the availability of a large
enough supercomputer to reduce the final matrix.

So any suggestetions of how to summarise the "hardness" of a problem
when it includes memory and cpu costs in as simple terms as possible.
(Bearing in mind the reader in most cases hasn't grasped the
difference between public key crypto and symmetric key, and is
comparing 1024 bit keys to 56 bit keys and probably thinks that it is
1024/56 times harder.)

> > About 10 years ago now Michael Wiener made a design for such a DES
> > breaking machine.  He estimated it would cost $10,000,000 to build a
> > machine which would break a 56 bit DES encrypted message a few hours.
> > His machine was scalable, pay more money, break the key faster, pay
> > less take longer.  The estimate was that could build one with enough
> > DES key searching units to break it in a day for $1,000,000.  That was
> > 10 years ago.  10 years is a long time in the computer industry.
> > Nowadays you build the machine more cheaply as chip technology has
> > progressed, and computers are much faster per $.  Estimates are around
> > $100,000 to build the machine (neglecting hardware engineers
> > consultancy fees).
>
> Go back and check the numbers - if you don't the journalists will.
> (I don't have this paper to hand either :-( ) The Wiener paper is
> much more recent (93?) , and the cost much lower (I think it was
> about $1M for HW and $500K for development costs, for a 3.5 hour
> machine).

I think I have his paper as a postscript file, will look.

But what do you think of the extrapolation to todays prices?  $100k?
(Ignoring consultancy fees).

Thanks for the criticisms, more please on readability and
understandability to neophytes!

Adam
--
Have *you* exported RSA today? --> http://www.dcs.ex.ac.uk/~aba/rsa/

print pack"C*",split/\D+/,`echo "16iII*o\U@{$/=$z;[(pop,pop,unpack"H*",<>
)]}\EsMsKsN0[lN*1lK[d2%Sa2/d0<X+d*lMLa^*lN%0]dsXx++lMlN/dsM0<J]dsJxp"|dc`

{% endraw %}
```

## Thread

+ Return to [June 1997](/archive/1997/06)

+ Return to "[? the Platypus {aka David Formosa} <dformosa@st.nepean.uws.edu.au>](/authors/_the_platypus_aka_david_formosa_dformosa_at_st_nepean_uws_edu_au_)"
+ Return to "[Adam Back <aba@dcs.ex.ac.uk>](/authors/adam_back_aba_at_dcs_ex_ac_uk_)"
+ Return to "[Jason William RENNIE <jrennie@hardy.ocs.mq.edu.au>](/authors/jason_william_rennie_jrennie_at_hardy_ocs_mq_edu_au_)"

+ _Unknown thread root_
  + 1997-06-24 (Tue, 24 Jun 1997 23:09:05 +0800) - Re: Comparing Cryptographic Key Sizes - _Adam Back<EMAIL_ADDRESS>    + 1997-06-24 (Wed, 25 Jun 1997 05:49:58 +0800) - [Re: Comparing Cryptographic Key Sizes](/archive/1997/06/8e693c580ad5adc078e3331a0e0faca9ba9a4925561b8f171225836c970996d5) - _Jason William RENNIE<EMAIL_ADDRESS>      + 1997-06-24 (Wed, 25 Jun 1997 07:12:20 +0800) - [Re: Comparing Cryptographic Key Sizes](/archive/1997/06/d7a6354f7df675ff8efe28e08a2d10ca5245685076fcc7ded74556932b28924d) - _? the Platypus {aka David Formosa}<EMAIL_ADDRESS>      + 1997-06-24 (Wed, 25 Jun 1997 07:15:21 +0800) - [intro to public key crypto (was Re: Comparing Cryptographic Key Sizes)](/archive/1997/06/83ef7f8ef4ab267cebafbd7461ea7a3efad1a7428286e8240c238fc19820a8ef) - _Adam Back<EMAIL_ADDRESS>


text:
Horriblegrabber
===============

A ~~small~~ horrible script meant for downloading ~~ongoing~~ horrible anime.

This script rips the magnet link out of HorribleSubs' RRS feed and blabs it into the browser. Luckily that browser just so happens to ~~usually~~ redirect it to your torrent client :ok_hand:.

Plus it also makes a `hist` file for keeping track of which magnets have been downloaded already.

## Usage
Put a file named `tasklist.json` in the same directory as the `horriblegrabber.py` containing a list of animes like in the following example:
```json
{
    "animes" : [
        "Boku no Hero Academia",
        "Date a Live",
        "Qualidea Code"
    ]
}
```

It can only rip items that are in their RSS feed, meaning not everything from HorribleSubs can be added instantaneously.

## Requirements
* [feedparser](https://pypi.python.org/pypi/feedparser)

## License
[Apache 2.0 license](LICENSE)

## Anime or Animes
[Wiktionary says both is ok so gfy](https://en.wiktionary.org/wiki/anime#Noun)

[![](http://www.reactiongifs.com/r/bth.gif)](https://en.wiktionary.org/wiki/anime#Noun)

repository: theolice/Horriblegrabber

repo_name: theolice/Horriblegrabber


text:
---
layout: post
title: "And Then Summer..."
date: 2013-06-03 11:46
comments: true
categories:
---

With the heat and humidity we've been having here on the East coast you
would think that summer is already here. Don't despair, think of this
weather as an opportunity to stay inside where it is air conditioned and
participate in some of the upcoming Ruby Hangouts!

Last month we were extremely fortunate to have with us [John Athayde],
of [The Rails View] fame. John gave an exremely useful talk on
organizing the view layer of Rails. Some of the topics he touched on
included dealing with legacy code, things you should avoid doing, the
amazing and awesome power of SASS/SCSS, the usefulness of presenters and
useful ways of organizing and re-using your code through partials.

After his talk John answered numerous audience questions ranging from
things to do when you come on to an ugly project that has 1000 line view
files, the good and bad of twitter bootstrap to what to do when you are
a developer and you don't have access to a designer. It is definitely
worth watching the whole talk [here].

Next month we have [Brian Cardarella] who will be talking about some of
the amazing gems that his company, [Dockyard], maintains as well as
[Ember.js].

The Picks
---------

* [Dotenv] - A project for loading environment variables
* [Extfs] - Working with linux drives from OSX
* [Ruby on Sails] - Day of sailing before Rubyconf.
* [Raspberry Pi] - $25 computer for hacking
* [Upgradingtorails4] - A book by [Andy Lindeman] on upgrading your app
  to rails 4.
* [The Phoenix Project] - A book on project management that highlights
  what "not to do."
* [Angularjs] - Best javascript framework out there.
* [Virtus] - Ruby objects on steroids.
* [Artemis] - Bridge spaceship simulator.
* [Food Fight Show] - Best devops podcast out there.
* [Spaceteam] - Multiplayer iphone game.
* [Crafting Rails Applications] - 2nd edition of [Jose Valim]'s great
  book.
* [Sync] - Gem for real time rails partials.

######Remember that this talk and all the others are available on our [youtube channel].######

  [John Athayde]: https://www.twitter.com/boboroshi
  [The Rails View]: http://www.therailsview.com/
  [here]: http://www.youtube.com/watch?v=4-NDYWXcl98
  [Brian Cardarella]: https://www.twitter.com/bcardarella
  [Dotenv]: https://github.com/bkeepers/dotenv
  [Extfs]: http://www.paragon-software.com/home/extfs-mac/
  [Ruby on Sails]: http://rubyconf.org/
  [Raspberry Pi]: http://www.raspberrypi.org/
  [Upgradingtorails4]: http://www.upgradingtorails4.com/
  [Andy Lindeman]: https://twitter.com/alindeman
  [Dockyard]: http://dockyard.com/
  [Ember.js]: http://emberjs.com/
  [youtube channel]: http://www.youtube.com/channel/UCZKYKp38YY-hl5HlK1PRk1w?feature=watch
  [The Phoenix Project]: http://www.amazon.com/The-Phoenix-Project-Helping-Business/dp/0988262592
  [Angularjs]: http://angularjs.org/
  [Virtus]: https://github.com/solnic/virtus
  [Artemis]: http://www.artemis.eochu.com/
  [Food Fight Show]: http://foodfightshow.org/
  [Spaceteam]: https://itunes.apple.com/us/app/spaceteam/id570510529?mt=8
  [Crafting Rails Applications]: http://pragprog.com/book/jvrails/crafting-rails-applications
  [Jose Valim]: https://twitter.com/josevalim
  [Sync]: https://github.com/chrismccord/sync

repository: jszmajda/therubyhangout

repo_name: jszmajda/therubyhangout


text:
# node-firefox-uninstall-app [![Build Status](https://secure.travis-ci.org/mozilla/node-firefox-uninstall-app.png?branch=master)](http://travis-ci.org/mozilla/node-firefox-uninstall-app)

> Uninstall an installed app on a runtime.

This is part of the [node-firefox](https://github.com/mozilla/node-firefox) project.

*NOTE: This module is super experimental and the API is not totally stable yet. Use under your own responsibility.*

## Installation

### From git

```bash
git clone https://github.com/mozilla/node-firefox-uninstall-app.git
cd node-firefox-uninstall-app
npm install
```

If you want to update later on:

```bash
cd node-firefox-uninstall-app
git pull origin master
npm install
```

### npm

```bash
npm install node-firefox-uninstall-app
```

## Usage

```javascript
uninstallApp(options) // returns a Promise
```

where `options` is a plain `Object` which must contain the following:

* `manifestURL`: the manifest URL *in the client* (you must have obtained this after a call to <tt>node-firefox-find-app</tt>. It's something that looks like: `manifestURL: 'app://13ab1444-736d-8c4b-83a6-b83afb5f1ea4/manifest.webapp'` in the result from `findApp`.
* `client`: the remote client from where we want to uninstall this app

If no `options` are provided, or if `options` is an empty `Object` (`{}`), then `uninstallApp` will fail (how can you uninstall *you don't know what app exactly* from *you don't know where*?)

### Installing and uninstalling a packaged app on a simulator

```javascript
startSimulator().then(function(simulator) {
  connect(simulator.port).then(function(client) {
    findApp({ client: client, manifest: manifest }).then(function(apps) {
      console.log('Found', apps.length, 'apps');
      Promise.all(apps.map(function(app) {
        console.log('Uninstalling', app.manifestURL);
        return uninstallApp({ manifestURL: app.manifestURL, client: client });
      })).then(function(results) {
        console.log('Installing', appPath);
        installApp({ appPath: appPath, client: client }).then(function() {
          findApp({ client: client, manifest: manifest }).then(function(app) {
            var firstApp = app[0];
            launchApp({ client: client, manifestURL: firstApp.manifestURL }).then(function(done) {
              console.log('Launched app');
            }, function(err) {
              console.error('App could not be launched', err);
            });
          });
        });
      });
    });
  });
});

```

You can have a look at the `examples` folder for a complete example.

## Running the tests

After installing, you can simply run the following from the module folder:

```bash
npm test
```

To add a new unit test file, create a new file in the `tests/unit` folder. Any file that matches `test.*.js` will be run as a test by the appropriate test runner, based on the folder location.

We use `gulp` behind the scenes to run the test; if you don't have it installed globally you can use `npm gulp` from inside the project's root folder to run `gulp`.

### Code quality and style

Because we have multiple contributors working on our projects, we value consistent code styles. It makes it easier to read code written by many people! :-)

Our tests include unit tests as well as code quality ("linting") tests that make sure our test pass a style guide and [JSHint](http://jshint.com/). Instead of submitting code with the wrong indentation or a different style, run the tests and you will be told where your code quality/style differs from ours and instructions on how to fix it.

## License

This program is free software; it is distributed under an
[Apache License](https://github.com/mozilla/node-firefox-uninstall-app/blob/master/LICENSE).

## Copyright

Copyright (c) 2015 [Mozilla](https://mozilla.org)
([Contributors](https://github.com/mozilla/node-firefox-uninstall-app/graphs/contributors)).

repository: mozilla/node-firefox-uninstall-app

repo_name: mozilla/node-firefox-uninstall-app


text:
## Videos
* [Prototypes in JavaScript - FunFunFunction #16](https://www.youtube.com/watch?v=riDVvXZ_Kb4)
* [9.19: Prototypes in Javascript - p5.js Tutorial](https://www.youtube.com/watch?v=hS_WqkyUah8)
* [Javascript Prototype inheritance Explained](https://www.youtube.com/watch?v=7oNWNlMrkpc)

## Various Links
* [StackOverflow: Equivalent of Prototype in ES6](https://stackoverflow.com/questions/41194904/equivalent-of-prototype-in-es6)
* [JavaScript Prototype Explained By Examples](http://www.javascripttutorial.net/javascript-prototype/)
* [A Plain English Guide to JavaScript Prototypes](http://sporto.github.io/blog/2013/02/22/a-plain-english-guide-to-javascript-prototypes/)
* [Understanding Javascript Prototypes](https://www.pluralsight.com/blog/software-development/understanding-javascript-prototypes)
* [Inheritance and the prototype chain](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Inheritance_and_the_prototype_chain)
* [JavaScript Object Prototypes](https://www.w3schools.com/js/js_object_prototypes.asp)
* [JavaScript Prototype in Plain Language](http://javascriptissexy.com/javascript-prototype-in-plain-detailed-language/)
* [Prototypal Inheritance in JavaScript](https://medium.com/@kevincennis/prototypal-inheritance-781bccc97edb)
* [Understanding the JavaScript Prototype Chain & Inheritance](https://community.risingstack.com/javascript-prototype-chain-inheritance/)
* [Understanding "Prototypes" in JavaScript](http://yehudakatz.com/2011/08/12/understanding-prototypes-in-javascript/)


text:
This directory contains code to prepare a detectron2 model for deployment.
Currently it supports exporting a detectron2 model to TorchScript, ONNX, or (deprecated) Caffe2 format.

Please see [documentation](https://detectron2.readthedocs.io/tutorials/deployment.html) for its usage.

### Acknowledgements

Thanks to Mobile Vision team at Facebook for developing the Caffe2 conversion tools.

Thanks to Computing Platform Department - PAI team at Alibaba Group (@bddpqq, @chenbohua3) who
help export Detectron2 models to TorchScript.

Thanks to ONNX Converter team at Microsoft who help export Detectron2 models to ONNX.


text:
## `next-urql` - Custom Exchange Example

This example is a small reference of how to implement and use a custom exchange in your urql client with `next-urql`. The project is a small Pokedex querying the excellent [Pokemon GraphQL API](https://github.com/lucasbento/graphql-pokemon).

### Installation

To get the example project running, follow these two steps:

```sh
yarn
yarn start
```

The example project should spin up at `http://localhost:3000`. `yarn start` will always run the build of the `next-urql` source, so you should see changes picked up once the dev server boots up. However, if you make changes to the `next-urql` source while the dev server is running, you'll need to run `yarn start` again to see those changes take effect.


text:
# Design Pattern Decisions

The contracts, Marketplace and Store invite code reviewers with healthily-commented sections to study descriptions of what the various components like functions, structs, etc do.

## Marketplace Contract

The MEW Marketplace contract is the generalized root level, that defines information about MEW Adopters, MEW Store owners and Admins. The storage variables utilize mappings instead of arrays to make looping more efficient.

## Store Contract

The MEW Store contract are what MEW adopters and MEW store owners interact with when they "adopt" MEW products. Each MEW store created is really a Store contract instance. Each instance is responsible for maintaining its balance of ether.

## Emergency Stop

Emergency stops are facilitated at the Store contract level because this is the primary level where adopters and store owners interact.

## Safe Math

OpenZeppelin's library was used to prevent integer flow attacks and perform arithmetic computations responsibly in Store contracts.


text:
---
layout: post
title: "OsSOAR1"
description: ""
category: genes
tags: [salt tolerance]
---

* **Information**
    + Symbol: OsSOAR1
    + MSU: [LOC_Os01g32170](http://rice.uga.edu/cgi-bin/ORF_infopage.cgi?orf=LOC_Os01g32170)
    + RAPdb: [Os01g0506100](https://rapdb.dna.affrc.go.jp/locus/?name=Os01g0506100)

* **Publication**
    + [The PPR-Domain Protein SOAR1 Regulates Salt Tolerance in Rice.](http://www.ncbi.nlm.nih.gov/pubmed?term=The PPR-Domain Protein SOAR1 Regulates Salt Tolerance in Rice.%5BTitle%5D), 2022, Rice (N Y).

* **Genbank accession number**

* **Key message**
    + Further, we overexpressed the homologous gene of SOAR1 in rice, OsSOAR1, and showed that transgenic plants overexpressing OsSOAR1 enhanced salt tolerance at seedling growth stage.

* **Connection**

[//]: # * **Key figures**