text:
[![Gem Version](https://badge.fury.io/rb/sugarcane.png)](http://badge.fury.io/rb/sugarcane)
[![Build Status](https://travis-ci.org/rlqualls/sugarcane.png?branch=master)](https://travis-ci.org/rlqualls/sugarcane)
[![Code Climate](https://codeclimate.com/github/rlqualls/sugarcane.png)](https://codeclimate.com/github/rlqualls/sugarcane)

![sugarcane screenshot](http://i.imgur.com/RP7xDLU.png)

> It's best to get beat with something sweet...

**Sugarcane** is an enhancement of the **cane** code quality tool. It makes various
minor changes, but most importantly, it closes the gap between the text editor
and cane.

You can find the original cane project at [square/cane](https://github.com/square/cane).

## Features

  - Go straight from violations to their lines in a text editor
  - Otherwise does what cane does
  - Editors supported: sublimetext (untested), vim, gedit, nano

## Controls

  - K,W, UP - up
  - J,S, DOWN - down
  - Q,X - quit
  - O, Enter, Space - open file in text editor at the violation

## Dependencies

### OSX

    $ brew install ncurses

### Ubuntu/Debian

    $ sudo apt-get install ncurses-dev

## Installation

    $ gem install sugarcane

## Installation (development)

    $ git clone https://github.com/rlqualls/sugarcane
    $ cd sugarcane
    $ bundle
    $ rake install

## Usage Examples

To run the default checks on all `.rb` files in your project, navigate to the
project root and run sugarcane.

    $ sugarcane

If you just want to run all checks on a specific file:

    $ sugarcane -f README.md

If you want to run checks on files matching a pattern:

    $ sugarcane --abc-glob '{lib,spec}/**/*.rb' --abc-max 15

Sugarcane tries to find an editor in your PATH, choosing sublime then vim
first if one is available. You can specify a different editor with `--editor`.

    $ sugarcane --editor nano
    $ sugarcane --editor=gedit

**NOTE**: Right now, navigating to a line number relies on the convention
of `+<num_lines>` as an argument (sublimetext is included as an exception).

## Not far from the Tree

For original `cane` functionality, add the --report option

    $ sugarcane --report

    Methods exceeded maximum allowed ABC complexity (2):

      lib/sugarcane.rb  SugarCane#sample    23
      lib/sugarcane.rb  SugarCane#sample_2  17

    Lines violated style requirements (2):

      lib/sugarcane.rb:20   Line length >80
      lib/sugarcane.rb:42   Trailing whitespace

    Class definitions require explanatory comments on preceding line (1):
      lib/sugarcane:3  SomeClass

## Options

    $ sugarcane --help
    Usage: sugarcane [options]

    Default options are loaded from a .sugarcane file in the current directory.

    -r, --require FILE               Load a Ruby file containing user-defined checks
    -c, --check CLASS                Use the given user-defined check

        --abc-glob GLOB              Glob to run ABC metrics over (default: {app,lib}/**/*.rb)
        --abc-max VALUE              Ignore methods under this complexity (default: 15)
        --abc-exclude METHOD         Exclude method from analysis (eg. Foo::Bar#method)
        --no-abc                     Disable ABC checking

        --style-glob GLOB            Glob to run style checks over (default: {app,lib,spec}/**/*.rb)
        --style-measure VALUE        Max line length (default: 80)
        --style-exclude GLOB         Exclude file or glob from style checking
        --no-style                   Disable style checking

        --doc-glob GLOB              Glob to run doc checks over (default: {app,lib}/**/*.rb)
        --doc-exclude GLOB           Exclude file or glob from documentation checking
        --no-readme                  Disable readme checking
        --no-doc                     Disable documentation checking

        --lt FILE,THRESHOLD          Check the number in FILE is < to THRESHOLD (a number or another file name)
        --lte FILE,THRESHOLD         Check the number in FILE is <= to THRESHOLD (a number or another file name)
        --eq FILE,THRESHOLD          Check the number in FILE is == to THRESHOLD (a number or another file name)
        --gte FILE,THRESHOLD         Check the number in FILE is >= to THRESHOLD (a number or another file name)
        --gt FILE,THRESHOLD          Check the number in FILE is > to THRESHOLD (a number or another file name)

    -f, --all FILE                   Apply all checks to given file
        --max-violations VALUE       Max allowed violations (default: 0)
        --editor PROGRAM             Text editor to use
        --json                       Output as JSON
        --report                     Original cane output
        --parallel                   Use all processors. Slower on small projects, faster on large.
        --color                      Colorize output

    -v, --version                    Show version
    -h, --help                       Show this message

## Configuration Files

Set default options using a `.cane` or `.sugarcane`. This is easier than telling
sugarcane what editor you want to use every time.

    $ cat .sugarcane
    --no-doc
    --abc-glob **/*.rb
    --editor gedit

It works exactly the same as specifying the options on the command-line.
Command-line arguments will override arguments specified in the configuration
file. Sugarcane will ignore a `.cane` file if it sees a `.sugarcane` file.

## Integrating with Rake

Sugarcane retains the ability to create rake tasks. The tasks will look for
configuration files the same way running sugarcane normally does. The build
will fail if the task finds more than `max_violations` violations which is 0
by default. Keep this in mind if using sugarcane tasks in continuous
integration.

```ruby
  require 'sugarcane/rake_task'

  desc "Run sugarcane to check quality metrics"
  SugarCane::RakeTask.new(:quality)

  task :default => :quality
end
```

Instead of using a configuration file, you can specify options in a block.
Rescuing `LoadError` is a good idea, since `rake -T` failing is totally
frustrating.

```ruby
begin
  require 'sugarcane/rake_task'

  desc "Run sugarcane to check quality metrics"
  SugarCane::RakeTask.new(:quality) do |cane|
    cane.abc_max = 10
    cane.no_style = true
    cane.max_violations = 3
    cane.abc_exclude = %w(Foo::Bar#some_method)
  end

  task :default => :quality
rescue LoadError
  warn "sugarcane not available, quality task not provided."
end
```

If you have multiple configuration files, you can specify which one to use
with `SugarCane::RakeTask#canefile=`. For that, the name does not matter.

## Implementing your own checks

Checks must implement:

* A class level `options` method that returns a hash of available options. This
  will be included in help output if the check is added before `--help`. If
  your check does not require any configuration, return an empty hash.
* A one argument constructor, into which will be passed the options specified
  for your check.
* A `violations` method that returns an array of violations.

See existing checks for guidance. Create your check in a new file:

```ruby
# unhappy.rb
class UnhappyCheck < Struct.new(:opts)
  def self.options
    {
      unhappy_file: ["File to check", default: [nil]]
    }
  end

  def violations
    [
      description: "Files are unhappy",
      file:        opts.fetch(:unhappy_file),
      label:       ":("
    ]
  end
end
```

Include your check either using command-line options:

    sugarcane -r unhappy.rb --check UnhappyCheck --unhappy-file myfile

Or in your rake task:

```ruby
require 'unhappy'

SugarCane::RakeTask.new(:quality) do |c|
  c.use UnhappyCheck, unhappy_file: 'myfile'
end
```
## Compatibility

Requires MRI 1.9, since it depends on the `ripper` library to calculate
complexity metrics.  In other words, you can run Cane against your
1.8 or JRuby project.

## Support

Make a [new github issue](https://github.com/rlqualls/sugarcane/issues/new).

repository: rlqualls/sugarcane

repo_name: rlqualls/sugarcane


text:
### Example Scenario

Post-acute care patients are typically complex from a healthcare perspective and have many stops during their healthcare journey (as shown in Figure 1).  As the patient moves from one healthcare setting to another, it is important that their cognitive data travel with them so that the new healthcare setting has the most complete information about that patient so they can provide the best care.

The below example uses the following Post-Acute Care assessments:
* FASI: Functional Assessment Standardized Items
* MDS: Minimum Data Set
* OASIS: Outcome and Assessment Information Set
<br>

![Patient Journey](Patient_Journey.png){:style="float: none;"}

Figure 1: Example Post-acute Care Patient Healthcare Journey

### Assessment Data Exchange

In Figure 2, the patient is admitted to Healthcare Setting A due to the result of an adverse event, such as a stroke.  Healthcare setting A performs a set of Confusion Assessment Method (CAM) cognitive assessments, first by a registered nurse (e.g. at admission) and later, by a physical therapist (e.g. at discharge).  The results of the CAM cognitive assessments are captured in the electronic health record (EHR) system of Healthcare Setting A.

Upon discharge, Healthcare Setting A refers the patient to Healthcare Setting B.  When the patient arrives at Healthcare Setting B, their clinicians can retrieve the cognitive assessments performed on the patient at Healthcare Setting A, as part of the transfer summary, using the profiles for exchanging cognitive status data defined in this Implementation Guide.

The patient and their family can also access the assessments from Healthcare Setting A at any time through a mobile/web application, so that they are informed about the patient’s care, can track progress, and can be more engaged in their healthcare decisions.

![Cognitive Status Use Case](Cognitive_Status_Use_Case.png){:style="float: none;"}

Figure 2: Cognitive Status Use Case

repository: paciowg/cognitive-status-cli

branch_name: refs/heads/master

extension: md

gha_language: HTML

license_type: permissive

repo_name: paciowg/cognitive-status-cli


text:
Unity pivot baking samples using the Houdini node made for Unreal
==================================================================
This is a repository that contains examples on how to use the pivot baking
tool from SideFX in unity.

The project is provided AS IS, I will not provide any support for this,
you have the code, you have some samples and it's provided for free.

In the demo scene you can use the cursor keys to move the capsule around.

![alt text](Doc/PivotBaking01.PNG)

System requirements
-------------------

- Unity 2019.4.19f1

Creating you own compatible shader
----------------------------------
The provided shader has been made with Amplify shader editor and you can easily modify it to match your needs.
You need to install Amplify shader editor in the project in order to edit the shaders properly.
If you want to create an HLSL shader or HDRP/URP shader, it should be pretty straightforward to do it.

![alt text](Doc/PivotBaking02.PNG)

Houdini sample provided in the project
---------------------------------------
You can use freely the provided sample file. The Houdini file is located in the Resources directory and has been made with an educational version of Houdini.
You need to install the labs tools in order to export properly.

Can I use this freely?
-----------------------
Feel free to use this in your projects, improve it, modify it ...
Just don't sell it and make profit out of it please, it is free on purpose.

license: MIT

branch_name: refs/heads/main


text:
---
name: New Epic
about: Epic is a large piece of work, requiring more than a "Program Increment" (PI) to complete. Elaborate epics and break them down into features that can be completed within a PI
title: "[EPIC] "
labels: epic
assignees: ''
---

> ### Instructions
> NB: This template is only for core team members to be used as part of the management of the overall project
>
> **Delete this section when creating a new Epic, and complete all other sections.**
>
> Completing an Epic requires a significant investments. Stakeholders need to agree on their intent and definition. SAFe offers a reference template [Epic Hypothesis Statement](https://www.scaledagileframework.com/?ddownload=43239), and that was used to prepare this template.
>
> For further information, plese refer to: [SAFe Epic](https://www.scaledagileframework.com/epic/)

### Hypothesis Statement
- Funnel Entry Date: **The date that the epic entered the [funnel](https://www.scaledagileframework.com/program-and-solution-kanbans/)**
- Epic Name:  **A short name for the epic, should be the same as issue title**
- Epic Owner: **The name of the epic owner**

## Description

**An elevator pitch (value statement) that describes the epic in a clear and concise way**

	For *customers*
	who *do something*
	the *solution*
	is a *something – the ‘how’*
	that *provides this value*
	unlike *competitor, current solution or non-existing solution*
	our solution *does something better — the ‘why’*

## Outcomes
The measurable benefits that the business can anticipate if the epic hypothesis is proven to be correct

## Leading Indicators
The early measures that will help predict the business outcome hypothesis.
For more on this topic, see the Innovation Accounting advanced topic article

## Nonfunctional Requirements
Nonfunctional requirements (NFRs) associated with the epic

### Features

- [ ]

repository: Australian-Imaging-Service/charts

gha_language: Smarty

repo_name: Australian-Imaging-Service/charts


text:
---
type: rule
archivedreason:
title: Do you know the numbers you give clients?
guid: 0d966aa3-7c4c-4039-8a4e-792e6d148444
uri: do-you-know-the-numbers-you-give-clients
created: 2010-07-16T06:50:39.0000000Z
authors: []
related: []
redirects: []

---

When working on an hourly basis, you can confuse clients when sometimes you try to talk about a few hours here and a few hours here or there.
<!--endintro-->

Simply things and just give them these 3 numbers:

|

| $ Billed to date | \_\_$xx\_\_(accurate on Tuesday) |
| --- | --- |
| Burndown Days Remaining | \_\_8\_\_ |
| Calendar Days Booked | \_\_4days x 2\_\_ |
| Next meeting (for Review and Retro) |

 |
| --- |

Hi Andrew,
     Please find the Burndown report below. I have looked at a few tasks with Zune and re-estimated them.

* Product owner:Andrew
* Scrum master:Paul
* Team:Mark L,Zune,Tristan,Trevor
* $ Billed to date:$20,000
* Days remaining:(around 50 hours based on chart below)=7+days
* Days booked in are 4 days x 2
    * ML and ZV - Mon 5th
    * ML and ZV - Tue 6th
    * ML and ZV - Mon 12th
    * ML and ZV - Tue 13th
* Only the 14th we will
    * Move any remaining tasks to Sprint 4
    * Have a Review Meeting (show and tell) at 10am – 2 hours
    * Have a Retrospective Meeting at 12 noon – 2 hours
    * Have a Planning Meeting at 2pm

        Please let us know if you have any questions or concerns.


text:
# Paraview + TTK Docker Image

This docker file can be used to build docker images containing installations of the [Topology Tool Kit (TTK)](http://topology-tool-kit.github.io) and/or [ParaView](http://www.paraview.org) and corresponding dependencies for usage and development. For a description of the build process, see [Custom Images](##custom-images), for usageof the images, see [Simple Usage](##simple-usage) or [Advanced Usage](##advanced-usage).

The full docker image specifically contains:

- ParaView server with offscreen rendering using either [OSMesa](http://www.mesa3d.org/osmesa.html) or [OSPRay](http://www.ospray.org).
- TTK for ParaView plugins are installed.

It is supposed to be used in conjunction with a local ParaView GUI.

## Simple usage

To run Kitware's binary distribution of ParaView with TTK's docker, simply run:

```
./runParaViewTTKDocker.sh <Path to ParaView binary (version 5.10.1)> [<Standard ParaView arguments (state files, data, etc.)>]
```

To run a python script which uses TTK, simply run:

```
./runTTKPythonDocker.sh [<Standard pvpython arguments: Python script, data, etc. ABSOLUTE PATHS ONLY)>]
```

## Custom Images

To re-build the image, simply clone this repository and run `docker build .` (which will build a docker image with current versions of ParaView and TTK).

The Dockerfile can build different images using the following targets through `docker build --target <targetname> .`:
- `ttk` will build the default target containing ParaView and TTK. When run, the image starts a ParaView server on port 11111.
- `ttk-dev` will build a docker image containing an installation of ParaView built from source and development tools such as cmake. It can be used for development of your own version of TTK.

The Dockerfile supports building a specific TTK version using the `ttk` build argument. This can be set to the designation of any branch or tag from TTK's GitHub [repository](https://github.com/topology-tool-kit/ttk), e.g. "`master`" or "`v0.9.7`". The default value is the current ttk dev branch.

The Dockerfile supports building a specific ParaView version using the `paraview` build argument. This can be set to any release tag from ParaViews's [download page](https://www.paraview.org/download/), e.g. "`5.10.0`" or "`5.9.1`". Note however, that versions older than `5.9` are no longer maintained. The default value is the latest ParaView release.

For example, `docker build -t ttk --build-arg paraview=5.9.1 --build-argttk=1.0.0 .` builds a docker image which by default will run a ParaView 5.9.1 server containing a TTK 1.0.0 installation.

## Advanced usage

After building the image with `docker build -t <image-name> --build-arg paraview=<pv-version> --build-argttk=<ttk-version> .` you can run it with
```
docker run -it --rm -p 11111:11111 -v "$HOME:/home/`whoami`/" --user $UID <image-name>
```
or use the GitHub image with
```
docker run -it --rm -p 11111:11111 -v "$(pwd)/data:/home/paraview/data" --user $UID ghcr.io/scivislab/ttk:latest
```

which will start `pvserver` (version `<pv-version>`) with TTK (version <ttk-version>) and listen on the default port 11111 for connections from a ParaView GUI. The directory `$(pwd)/data` will be mounted under `/home/paraview/data` in the container.

If the container is executed on a remote host, consider using the command
```
ssh -L 11111:localhost:11111 user@host docker run ...
```
which will set up the appropriate port forwarding as well. The GUI should then be able to connect to `localhost:11111`.

Notes:
- The versions of the ParaView GUI and `pvserver` have to match exactly.
- `pvserver` will currently exit after the GUI has disconnected, i.e. the container must be restarted.

repository: topology-tool-kit/ttk

branch_name: refs/heads/dev

gha_license_id: NOASSERTION

repo_name: topology-tool-kit/ttk


text:
# android-library

### Run single test

```
./gradlew cAT -Pandroid.testInstrumentationRunnerArguments.class=com.moquality.android.AppTest
```

Create screenshots folder
```
adb shell
cd /sdcard/Pictures
mkdir screenshots
```

Screenshots are in the Pictures/screenshots folder. Command to pull.
```
adb pull /sdcard/Pictures/screenshots .
```

repository: moquality/android-library

repo_name: moquality/android-library


text:
# Daily News

Hey ! Daily News is a news app written with %100 programmatically ui.

# Usage
It is powered by NewsAPI! You should get your free developer API key from [NewsAPI](https://newsapi.org) and add it to DailyNews/Networking/FetchNews.swift.

# Features

-Side Menu with screen edge pan and tap gestures.

-Dispatch Group

-Nested collection views.

-Custom views and layouts

-Pagination

-Custom Delegation

-Programmatically UI

# ScreenShots

![](DailyNewsScreenShots/dailyNewsScreenshot.png)
![](DailyNewsScreenShots/news.png)
![](DailyNewsScreenShots/sideMenu.png)
![](DailyNewsScreenShots/sideMenu2.png)
![](DailyNewsScreenShots/categories.png)
![](DailyNewsScreenShots/categories2.png)
![](DailyNewsScreenShots/search.png)
![](DailyNewsScreenShots/sources.png)

## 3rd Party Libraries

-[SDWebImage](https://github.com/SDWebImage/SDWebImage) for asynchronous image downloading and caching.

## Licanse

MIT

repository: carabina/DailyNews

gha_license_id: MIT

repo_name: carabina/DailyNews


text:
Content Delivery API

Contributing

  Readme ·
  Migration ·
  Advanced ·
  Typescript ·
  Contributing

We appreciate any community contributions to this project, whether in the form of issues or pull requests.

This document outlines what we'd like you to follow in terms of commit messages and code style.

It also explains what to do in case you want to set up the project locally and run tests.

**Working on your first Pull Request?** You can learn how from this extensive [list of resources for people who are new to contributing to Open Source](https://github.com/freeCodeCamp/how-to-contribute-to-open-source).

## Setup

This project is written in ES2015 and transpiled to ES5 using Babel, to the `dist` directory. This should generally only happen at publishing time, or for testing purposes only.

Run `npm install` to install all necessary dependencies. When running `npm install` locally, `dist` is not compiled.

All necessary dependencies are installed under `node_modules` and any necessary tools can be accessed via npm scripts. There is no need to install anything globally.

When importing local, in development code, via `index.js`, this file checks if `dist` exists and uses that. Otherwise, it uses the code from `lib`.

If you have a `dist` directory, run `npm run clean`.

## Useful npm scripts

- `npm run clean` removes any built files
- `npm run build:dev` builds vendored files, node package and browser version
- `npm run build:prod` builds production-ready minified sources
- `npm run build` combines `clean`, `build:dev` and `build:prod`
- `npm run build:types` emits type declaration files for js files

## Running tests

This project has unit and integration tests, as well as tests checking types. All of these run on both Node.js and browser environments.

Both of these test environments are setup to deal with Babel and code transpiling, so there's no need to worry about that.

- `npm run test:unit` runs Node.js unit tests
- `npm run test:integration` runs the integration tests against the Contentful CDA API
- `npm run test:types` runs type checking tests
- `npm test` runs linting on the test code and runs all three kinds of tests
- `test:demo-node` runs a Node.js demo application and its tests, making sure that Node.js builds are functioning and are bundled correctly
- `test:demo-browser` runs a browser client demo application and its tests, making sure that browser builds are functioning and are bundled correctly
- `test:demo-projects` runs both Node.js and browser application tests

## Documentation

Code is documented using TypeDoc, and reference documentation is published automatically with each new version.

- `npm run docs:watch` watches code directory, and rebuilds documentation when anything changes. Useful for documentation writing and development
- `npm run docs:build` builds documentation
- `npm run docs:publish` builds documentation and publishes it to github pages

## Code style

This project uses ESLint configuration from [standard](https://github.com/feross/standard). Install a relevant editor plugin if you'd like.

Everywhere where it isn't applicable, follow a style similar to the existing code.

## Commit messages and issues

This project uses the [Angular JS Commit Message Conventions](https://docs.google.com/document/d/1QrDFcIiPjSLDn3EL15IJygNPiHORgU1_OOAqWjiDU5Y/edit), via semantic-release. See the semantic-release [commit message format](https://github.com/semantic-release/semantic-release#commit-message-format) section for more details.

## Versioning

This project strictly follows [Semantic Versioning](http://semver.org/) by use of [semantic-release](https://github.com/semantic-release/semantic-release).

This means that new versions are released automatically as fixes, features or breaking changes are released.

You can check the changelog on the [releases](https://github.com/contentful/contentful.js/releases) page.

gha_language: TypeScript


text:
#requirejs-glob
A RequireJS plugin for loading multiple files that match a glob pattern.

##Why
Most of the time when using [RequireJS](http://requirejs.org/) you want to explicitly declare each file's dependencies. But there are certain situations where it would be more convenient to load a whole handful of files that have a flat dependency tree. For example when using [Angular](http://angularjs.org/) dependencies are "injected", so the order your controllers, services, templates etc. are loaded doesn't matter. For cases like these, the `glob!` plugin can be super useful:

```js
require([
  'glob!controllers/**/*.js',
  'glob!services/**/*.js',
  'glob!filters/**/*.js',
  'glob!directives/**/*.js',
]);
```

Now as you develop your application all new matching files will be included automatically. Each file will also be inlined during the [r.js build](http://requirejs.org/docs/optimization.html).

##How
The Browser environment has no way to find glob-matching files. So this plugin has a tiny server-side companion that runs during development only, listening for requests from the `glob!` plugin and returning lists of matching files.

One could accomplish something similar with a pre-run compile step like [Grunt](http://gruntjs.com/) or [Component](https://component.jit.su/), but part of the beauty of [RequireJS](http://requirejs.org/) is that it runs natively in the browser without the need for a build step. Most projects already use a webserver during development anyway. I like to think of this approach as "JIT Compiled AMD" plugin.

This piece is currently available as a [Connect](http://www.senchalabs.org/connect/) and [Express](http://expressjs.com/guide.html) compatible middleware.

##Getting Started
Install the plugin with [Bower](http://twitter.github.com/bower/):
`$ bower install requirejs-glob`
or download [glob.js](lib/glob.js) manually.

Add `glob` to your paths config that points to wherever you installed the glob.js file:

```js
require.config({
  paths: {
    "glob": "../components/requirejs-glob/lib/glob"
  }
})
```

Add a `glob` setting to your RequireJS config, that will instruct the server-side piece where to start for the pattern matching:

```js
require.config({
  glob: 'app/js/'
})
```
It should be the **full path** from the root of your project to the [baseUrl](http://requirejs.org/docs/api.html#config-baseUrl) where RequireJS looks to load your scripts from.

Install the [Node](http://nodejs.org/) companion with [npm](https://npmjs.org/):
`$ npm install requirejs-glob`

Use the requirejs-glob express middleware in your **development environment**:

```js
app.configure('development', function(){
  //use requirejs-glob middleware
  app.use(require('requirejs-glob')());
});
```

Once you're all setup you can use the plugin:

```js
require(['glob!controllers/**/*.js'], function(){});
```

Enjoy!

##Grunt integration

The middleware can also be used as part of a [Grunt][] build, where the web server
is created with the [grunt-contrib-connect][] task.  To do this, the grunt
task must be configured with custom middleware.

For a registered task named `connect:server`, where compiled files are placed
in the `generated` directory, use the [middleware][] configuration option to
load support for the requirejs glob middleware.

```javascript
connect: {
  server: {
    options: {
      base: "generated",
      middleware: function(connect, options) {
        // Return array of whatever middlewares you want
        return [
          require('requirejs-glob')(),
          // standard middleware for static files and dir browsing
          connect.static(options.base),
          connect.directory(options.base)
        ];
      }
    }
  }
}
```

[Grunt]: http://gruntjs.com/
[grunt-contrib-connect]: https://github.com/gruntjs/grunt-contrib-connect
[middleware]: https://github.com/gruntjs/grunt-contrib-connect#middleware

##License
MIT

##TODO
[] consider standalone for non-node backends
[] tests
[] examples

repository: coltpini/angNoMon-Startup

gha_language: JavaScript

repo_name: coltpini/angNoMon-Startup


text:
[![Discord Server Badge](https://img.shields.io/discord/745447009242316860?color=7289DA&label=Discord%20Server&logo=discord&logoColor=white&style=flat-square)](https://discord.gg/GuBufUE)![Programming Language](https://img.shields.io/badge/-Java-orange?style=flat-square&logo=java)

Discord Guild Greeter is a Discord Bot Module written in Java using the Javacord API which allows inexperienced developers to create a good quality greeting bot. It takes in up to 9 variables, some of which can be left blank.
For other projects, see [here](https://github.com/asciitac)

# Setup
Go to ``/discordGuildGreeter/src/main/java/configuration.java`` and set the given variables to your choosing.

``String`` ``TOKEN`` is your Discord Bot Token. This should be kept secret and can alternatively be an environment variable. You should not share this with anyone, as it gives them complete access to your Discord Account! You can get your bot token from ``https://discord.com/developers/applications/<YOUR PROJECT ID HERE>/bot``.

``Boolean`` ``sendPrivateMessage`` dictates if they recieve a direct message.

``String`` ``privateMessage`` is that direct message.

``Boolean`` ``isPrivateMessageEmbed`` dictates if the direct message comes in the form of an ``Embed``.

``Color`` ``privateMessageColor`` is the colour of that ``Embed``.

``Boolean`` ``sendChannelMessage`` dictates if the alert is sent to a ``serverTextChannel`` in a ``Server``

``String`` ``channelID`` is the ID of the ``serverTextChannel`` that the alert will be sent to.

``String`` ``channelMessage`` is the message that is sent to the ``serverTextChannel``

``Boolean`` ``isChannelMessageEmbed`` dictates if the message comes in the form of an ``Embed``.

``Color`` ``channelMessageColor`` is the colour of that ``Embed``.

Run ``/discordGuildGreeter/src/main/java/runMe.java`` to start the bot.

# Additional Notes
Skidding, the act of copying one's work without giving due credit, is highly advised against. I ask that you provide me credit wherever this is used. You can mention either @asciitac or @gigitac.

repository: asciitac/discordGuildGreeter

repo_name: asciitac/discordGuildGreeter


text:
---
title: "62 - export"
menu:
  main:
    name: "export"
    identifier: "technical/api/export"
    parent: "technical/api"
---
# Get exports

    GET /api/v1/export?token=<token>

Retrieves an overview of all exports owned by the user.

## Query String

|   |   |
|---|---|
| `token`    | Session token acquired with [/api/v1/session](/en/technical/api/session) |
| `limit`    | maximum number of returned exports (optional, integer, `1000` if unset, maximum: `1000`) |
| `offset`   | offset of first export to be returned (optional, integer, `0` if unset) |
| `filter`   | Comma-separated, disjunctive list of multiple filters.
Each filter may contain a `type` and/or a `status` filter part, multiple parts are separated by `+` and used in conjunction.
Each part consists of the filter variable name (either `type` or `status`) and its value(s), separated by `:`
Multiple values may be specified, separated by |
Example: `filter=type:download+status:failed,type:export_incremental`. Note, that `+` has to be URL-encoded (`%2B`) when used in query string. |

## Output

Object containing the following fields:

| Name         | Description  |
|--------------|--------------|
| `limit`      | requested maximum number of returned exports, `null` if not requested in URL |
| `offset`     | offset of first export to be returned, `0` if not requested in URL |
| `count`      | total number of exports found, ignoring `limit` |
| `objects`    | array of [exports](/en/technical/types/export). The exports do not include `_files`, `_downloads`, `_schedules` `_transports` and `_log`. |

## Permissions

The session must be authenticated. A user can only manage its own exports.

## HTTP status codes

|   |   |
|---|---|
| 200 | Success |
| 400 | [API error](/en/technical/errors): something is malformed |
| 403 | [Not Authenticated](/en/technical/errors): session is not authenticated |
| 500 | [Server error](/en/technical/errors): internal server error |

    GET /api/v1/export/<export-id>?token=<token>

Retrieves a specific export.

## Path parameters

|   |   |
|---|---|
| `export-id` | Export ID (integer) |

## Query String

|   |   |
|---|---|
| `token`    | Session token acquired with [/api/v1/session](/en/technical/api/session) |

## Output

An [export](/en/technical/types/export).

## Permissions

The session must be authenticated. A user can only manage its own exports.

## HTTP status codes

|   |   |
|---|---|
| 200 | Success |
| 400 | [API error](/en/technical/errors): something is malformed |
| 403 | [Not Authenticated](/en/technical/errors): session is not authenticated |
| 404 | [Not Found](/en/technical/errors): export `export_id` not found |
| 500 | [Server error](/en/technical/errors): internal server error |

# Create an export

    PUT /api/v1/export?token=<token>

Create a new export.

*TODO*: a secret passkey to access an Export's downloadable files, is generated and stored for the new Export.

## Query String

|   |   |
|---|---|
| `token`    | Session token acquired with [/api/v1/session](/en/technical/api/session) |

## Input

An [export](/en/technical/types/export).

## Output

The created [export](/en/technical/types/export).

## Permissions

The session must be authenticated.

## HTTP status codes

|   |   |
|---|---|
| 200 | Success |
| 400 | [API error](/en/technical/errors): something is malformed |
| 403 | [Not Authenticated](/en/technical/errors): session is not authenticated |
| 500 | [Server error](/en/technical/errors): internal server error |

# Update an export

    POST /api/v1/export/<export-id>?token=<token>

Update an export. POST only updates fields that are set, leaving the rest as they currently are.

*TODO*: if an update happens to an Export which is not in *done* or *new* state, the currently active Export is purged. After an update the Export gets again the *new* state.

## Path parameters

|   |   |
|---|---|
| `export-id` | Export ID (integer) |

## Query String

|   |   |
|---|---|
| `token` | Session token acquired with [/api/v1/session](/en/technical/api/session) |

## Input

An [export](/en/technical/types/export).

If the export is scheduled (there are one or more `_schedules`), it requires an explicitly set `name`.

## Output

The updated [export](/en/technical/types/export).

## Permissions

The session must be authenticated. A user can only manage its own exports.

## HTTP status codes

|   |   |
|---|---|
| 200 | Success |
| 400 | [API error](/en/technical/errors): something is malformed |
| 403 | [Not Authenticated](/en/technical/errors): session is not authenticated |
| 400 | [Export Name Required](/en/technical/errors): export requires a name |
| 404 | [Not Found](/en/technical/errors): export `export_id` not found |
| 500 | [Server error](/en/technical/errors): internal server error |

# Delete an export

    DELETE /api/v1/export/<export-id>?token=<token>

Delete export `export-id`.

## Path parameters

|   |   |
|---|---|
| `export-id` | Export ID (integer) |

## Query String

|   |   |
|---|---|
| `token`    | Session token acquired with [/api/v1/session](/en/technical/api/session) |

## Permissions

The session must be authenticated. A user can only manage its own exports.

## HTTP status codes

|   |   |
|---|---|
| 200 | Success |
| 400 | [API error](/en/technical/errors): something is malformed |
| 403 | [Not Authenticated](/en/technical/errors): session is not authenticated |
| 404 | [Not Found](/en/technical/errors): export `export_id` not found |
| 500 | [Server error](/en/technical/errors): internal server error |

# Get files from an Export

    GET /api/v1/v1/export/<export-id>/file/<path>?token=<token>

The `<path>` can be retrieved from the `_files` Array returned in the Export. Clients can use this to build an Export browser. `<path>` needs to be a file.

## Query String

|   |   |
|---|---|
| `token`        | Session token acquired with [/api/v1/session](/en/technical/api/session) |
| `disposition`  | If set, a *Content-Disposition* header is set in response. Valid values: *inline*, *attachment* |
| `filename`     | If set, an alternative name for the downloaded file is used. The file extension is added automatically. |

## HTTP status codes

|   |   |
|---|---|
| 200 | Success |
| 302 | Client is redirected to show an error page (using scheme `/#server_error:<localization key>`. This is only done if `disposition` parameter is set. |
| 400 | [API error](/en/technical/errors): something is malformed |

# Get files zipped from an Export

    GET /api/v1/v1/export/<export-id>/zip/<path>?token=<token>

The `<path>` can be retrieved from the `_files` Array returned in the Export. The ZIP format is ZIP64, if ZIP32 is required a transport has to be used. Single files or directories can be zipped. With no path given, the full export is zipped.

> The server generates the ZIP file on-thy-fly, so there is no Content-Length HTTP-Header set in the response.

|   |   |
|---|---|
| `token`        | Session token acquired with [/api/v1/session](/en/technical/api/session) |
| `disposition`  | If set, a *Content-Disposition* header is set in response. Valid values: *inline*, *attachment* |
| `filename`     | If set, an alternative name for the downloaded ZIP file is used. Defaults to export name and (if a path other than `"/"` is provided) the leaf path name with a `".zip"` suffix. The file extension (always `".zip"`) is added automatically. |

## HTTP status codes

|   |   |
|---|---|
| 200 | Success |
| 302 | Client is redirected to show an error page (using scheme `/#server_error:<localization key>`. This is only done if `disposition` parameter is set. |
| 400 | [API error](/en/technical/errors): something is malformed |

# Download files from an Export

> Each export generates a list of files to download the Export from. The *ZIP* files and *TAR* file is available through an anonymous access using a secret-passkey which is uniquely generated for each Export upon PUT.

## Get a downloadable files from an Export

    GET /api/v1/v1/export/<export-id>/download/<secret-passkey>/<name-of-export>[.<1-n>].zip>
    GET /api/v1/v1/export/<export-id>/download/<secret-passkey>/<name-of-export>.zip>
    GET /api/v1/v1/export/<export-id>/download/<secret-passkey>/<name-of-export>.tar>

The URL can be retrieved from the `_download` Map returned in the Exports Transports List.

Only Exports in the `done` state can be downloaded.

The URL can be retrieved from the `_download` Map returned in the Exports Transports List.

> The URL for a downloadable file will be persistent over the lifetime of an export.

|   |   |
|---|---|
| `token`        | Session token acquired with [/api/v1/session](/en/technical/api/session) |
| `disposition`  | If set, a *Content-Disposition* header is set in response. Valid values: *inline*, *attachment* |
| `filename`     | If set, an alternative name for the downloaded file is used. The file extension is added automatically. |

## Get with an invalid secret-passkey

If the secret-passkey used is invalid, the server uses a response with a "HTTP Location" redirect to redirect the Requester to a Frontend-URL to display a server error.

> //#server_error:export.invalid.passkey

## HTTP status codes

|   |   |
|---|---|
| 200 | Success |
| 302 | Client is redirected to show an error page (using scheme `/#server_error:<localization key>`. This is only done if `disposition` parameter is set. |
| 400 | [API error](/en/technical/errors): something is malformed |

# Start an export

The export is queued to run immediately.

	POST /api/v1/export/<export-id>/start?token=<token>

## Path parameters

|   |   |
|---|---|
| `export-id` | Export ID (integer) |

## Query String

|   |   |
|---|---|
| `token`    | Session token acquired with [/api/v1/session](/en/technical/api/session) |

## Permissions

The session must be authenticated. A user can only manage its own exports.

## HTTP status codes

|   |   |
|---|---|
| 200 | Success |
| 400 | [API error](/en/technical/errors): something is malformed |
| 400 | [Already Running](/en/technical/errors): the export requested to start is already running |
| 403 | [Not Authenticated](/en/technical/errors): session is not authenticated |
| 404 | [Not Found](/en/technical/errors): export `export_id` not found |
| 500 | [Server error](/en/technical/errors): internal server error |

# Stop an export

	POST /api/v1/export/<export-id>/stop?token=<token>

## Path parameters

|   |   |
|---|---|
| `export-id` | Export ID (integer) |

## Query String

|   |   |
|---|---|
| `token`    | Session token acquired with [/api/v1/session](/en/technical/api/session) |

## Permissions

The session must be authenticated. A user can only manage its own exports.

## HTTP status codes

|   |   |
|---|---|
| 200 | Success |
| 400 | [API error](/en/technical/errors): something is malformed |
| 403 | [Not Authenticated](/en/technical/errors): session is not authenticated |
| 404 | [Not Found](/en/technical/errors): export `export_id` not found or not running |
| 500 | [Server error](/en/technical/errors): internal server error |

repository: programmfabrik/easydb-documentation

gha_language: Go

repo_name: programmfabrik/easydb-documentation


text:
---
bg: "owl.jpg"
layout: page
title: "About"
crawlertitle: "brief description of the author"
permalink: /about/
summary: "About me"
active: about
---

<img name='name_cn' style="width=80px; height:60px;"  src="{{ site.images }}/name_cn.png" />

### Vector Chow

Email: zdengqing#126.com

You can also find me here:

- [GitHub](https://github.com/freevector)

### Biography

I received my Mphi. degree in Engineering Thermophysics in June 2015 from Shanghai Jiao Tong University. Currently I am working as an refrigeration system engineer in Midea. You could find my [CV](https://github.com/freevector/freevector.github.io/blob/master/CV_ZHOU.pdf)  by click it.
### Research Interest

Currently I am focusing on centrifgual chiller design, CFD skills, like ansys, openfoam etc.

During my master period, my research was focused on the heat transfer of nanofluids, which is a kind of novel material. Now I am interestd in the following things:

>* **Python**
>* **Latex**
>* **OpenFOAM/C++**
>* **CFX & Fluent**
>* **CFD skills**
>* **Dynamic Mode Decomposition**


text:
## SubscribeToHead

Sends the blockchain head every time it has been updated.

### Method

`SubscribeToHead`

### Channel

`head`

### Parameters

No parameters.

### Data model

Same as in [/head](#tag/Head)

### State

State contains level (`int`) of the last processed head.

### Example

````js
connection.on("head", (msg) => { console.log(msg); });
await connection.invoke("SubscribeToHead");
````

---

## SubscribeToBlocks

Sends blocks added to the blockchain

### Method

`SubscribeToBlocks`

### Channel

`blocks`

### Parameters

No parameters.

### Data model

Same as in [/blocks](#operation/Blocks_GetHead)

### State

State contains level (`int`) of the last processed block.

### Example

````js
connection.on("blocks", (msg) => { console.log(msg); });
await connection.invoke("SubscribeToBlocks");
````

---

## SubscribeToOperations

Sends operations of specified types or related to specified accounts, included into the blockchain

### Method

`SubscribeToOperations`

### Channel

`operations`

### Parameters

````js
{
	address: '', // address you want to subscribe to,
	             // or null if you want to subscribe for all operations

	types: ''    // comma-separated list of operation types, any of:
	             // 'transaction', 'origination', 'delegation', 'reveal'
				 // 'double_baking', 'double_endorsing', 'nonce_revelation', 'activation'
				 // 'proposal', 'ballot', 'endorsement.
}
````

> **Note:** you can invoke this method multiple times with different parameters to register multiple subscriptions.

### Data model

Same as in [/operations/transactions](#operation/Operations_GetTransactions), [/operations/delegations](#operation/Operations_GetDelegations), etc.

### State

State contains level (`int`) of the last processed block.

### Example

````js
connection.on("operations", (msg) => { console.log(msg); });
// subscribe to all transactions
await connection.invoke("SubscribeToOperations", { types: 'transaction' });
// subscribe to all delegations and originations related to the address 'tz1234...'
await connection.invoke("SubscribeToOperations", { address: 'tz1234...', types: 'delegation,origination' });
````

---

## SubscribeToBigMaps

Sends bigmap updates

### Method

`SubscribeToBigMaps`

### Channel

`bigmaps`

### Parameters

This method accepts the following parameters:

````js
{
	ptr: 0,         // ptr of the bigmap you want to subscribe to
	tags: [],       // array of bigmap tags ('metadata' or 'token_metadata')
	contract: '',   // contract address
	path: ''        // path to the bigmap in the contract strage
}
````

You can set various combinations of these fields to configure what you want to subscribe to. For example:

````js
// subscribe to all bigmaps
{
}

// subscribe to all bigmaps with specific tags
{
	tags: ['metadata', 'token_metadata']
}

// subscribe  to all bigmaps of the specific contract
{
	contract: 'KT1...'
}

// subscribe to all bigmaps of the specific contract with specific tags
{
	contract: 'KT1...',
	tags: ['metadata']
}

// subscribe to specific bigmap by ptr
{
	ptr: 123
}

// subscribe to specific bigmap by path
{
	contract: 'KT1...',
	path: 'ledger'
}
````

> **Note:** you can invoke this method multiple times with different parameters to register multiple subscriptions.

### Data model

Same as in [/bigmaps/updates](#operation/BigMaps_GetBigMapUpdates).

### State

State contains level (`int`) of the last processed block.

### Example

````js
connection.on("bigmaps", (msg) => { console.log(msg); });
// subscribe to all bigmaps of the 'KT123...' contract
await connection.invoke("SubscribeToBigMaps", { contract: 'KT123...' });
// subscribe to bigmap with ptr 123
await connection.invoke("SubscribeToBigMaps", { ptr: 123 });
````

---

repository: JuliusPeng/tzkt

repo_name: JuliusPeng/tzkt


text:
# CEP Aberto JavaScript SDK

[![Build Status](https://travis-ci.org/devsdmf/cepaberto.js.svg?branch=master)](https://travis-ci.org/devsdmf/cepaberto.js)
[![Coverage Status](https://coveralls.io/repos/github/devsdmf/cepaberto.js/badge.svg?branch=code-coverage)](https://coveralls.io/github/devsdmf/cepaberto.js?branch=code-coverage)

This is the JavaScript SDK for the CEP Aberto API to search for addresses and zipcodes directly from your JS application.

CEP Aberto is an Open Database Project that provides a free of charge zipcode database and a simple API that allows you to fetch the information on-the-fly.

## Installation

```
$ npm install --save cepaberto
```

## Usage

Importing the library to your code:

```javascript
const CEPAberto = require('cepaberto')

let cepaberto = new CEPAberto()
```

#### Find address by zipcode

```javascript
cepaberto.findByCode('30180-000')
         .then((address) => console.log(address))
         .catch((err) => console.error(err))
```

If the address was not found, the address variable will be a `boolean false`.

#### Find address by coordinates

```javascript
cepaberto.findByCoordinates('-40.9182391','-12.0918236')
         .then((address) => console.log(address))
         .catch((err) => console.error(err))
```

#### Find zipcode by address

```javascript
cepaberto.findByAddress('MG', 'Belo Horizonte', 'Centro', 'Av. Amazonas')
         .then((address) => console.log(address))
         .catch((err) => console.error(err))
```

*Only the state and city parameters are mandatory because some zipcodes represents an entire city.*

#### Find cities

```javascript
cepaberto.findCities('MG')
         .then((cities) => console.log(cities))
         .catch((err) => console.error(err))
```

## Tests

```
$ npm test
```

## License

This library is licensed under the [MIT license](LICENSE).


text:
# Ansible-inventory-file-examples
Examples and counter-examples of Ansible inventory files

# Sources

Some of the examples in this repo are taken verbatim from documentation.
Starting with the obvious place, Ansible documentation:

http://docs.ansible.com/ansible/intro_inventory.html


text:
---
layout: post
title: "Look Ma! No keys!"
categories:
- technology
date: 2003-06-14 00:00
comments: true
---

I really should stop reading MacSlash. Not only do I have to wade through a lot of trolls, I see something ultra-cool and ultra-geeky and I want it — and be damned with the expense. Needless to say, I want one of these zero-force keyboard replacements from Fingerworks. I tried to find out if there are any resellers in the UK or elsewhere in Europe, and came upon this German site, which sells the iGesture Pad. I love the description:

Fé¼hlen Sie sich wie Tom Cruise in Minority Report!

Now, I only did a year of German at school, and virtually all I remember is that the verb comes at the end, but I think we all know what that means. By coincidence, I've been getting a bit worried about RSI lately. I've started getting pains and nerve spasms in my hands. Yesterday, the little finger on my left hand kept twitching, and I ended up typing far too many 'a's. I wonder if I could wangle a Touchstream from the Occupational Health service at work?

repository: bsag/blog-octo

repo_name: bsag/blog-octo


text:
## RestaurantsGridContainer
A connected container that wraps around the restaurant grid on the landing page.

### Example Usage

```js
<RestaurantsGridContainer  />
// Props are connected through redux, not passed in.
```

  restaurants: state.restaurants.items,
  selectedFilterIndex: state.restaurants.selectedFilterIndex,
  isLoading: state.restaurants.isLoading,
  errors: state.restaurants.errors,
  categories: state.restaurants.categories,
  locations: state.restaurants.locations,
  ratings: state.restaurants.ratings,

### Props

| Prop          | Type     | Default     | Possible Values
| ------------- | -------- | ----------- | ---------------------------------------------
| **restaurants**    | Array   |             | An Array of restaurants to map to the grid items
| **selectedFilterIndex**    | String   |             | Indicates that a filter is selected for an item for cuisine type.
| **isLoading**    | Boolean   |             | Whether the container is loading its data
| **errors**    | Array   |             | An array of errors, if applicable
| **categories**    | Array   |             | Restaurant cuisine categories
| **locations**    | Array   |             | Unique locations of restaurants, used to filter by location
| **ratings**    | Array   |             | Unique ratings of restaurants, used to filter by rating

### Other Information
Connected container component that connects to the redux store for the restaurant grid.

#### Models

Restaurants:
```js
const myRestaurants = [
{
  id: 1,
    name: "The New Magnum Café",
    address: "Jalan M Husni Thamrin 1",
    city: "Jakarta Pusat",
    state:"Daerah Khusus Ibukota Jakarta",
    zip:"23435",
    country: "id",
    phone: "(021) 23580055",
    website: "http://mymagnum.co.id/",
  },
  {
    ...
  }
]
```

Errors:
```js
const errors = [
  {
    id: 0,
    message: 'My message',
  },
  {
    ...
  }
]
```

Categories:
```js
const categories = [
  {
    0:"All"
  },
  {
    1:"Cafe"
  }
];
```

Locations:
```js
const locations = [
  {
    id: 0,
    value: 'Brooklyn, NY',
  },
  {
    id: 1,
    value: 'Jakarta',
  }
];
```

Ratings:
```js
const ratings = [
  {
    id: 0,
    value: 'All',
  },
  {
    id: 1,
    value: '1 Star',
  }
];
```

repository: satishjhanwer/restaurant-reviewer

repo_name: satishjhanwer/restaurant-reviewer


text:
# <h1 align="center"> CSE3040 Java Programming (Fall 2020) - Programming Lab #03

#### **`03-1. Unary Operators >`**

##### * What will be printed on the display when you execute this program? (Refer to source code)
##### - Guess first, and then run this program and see the result for yourself.

#### **`03-2. Typecasting >`**

##### * What will be printed on the display when you execute this program? (Refer to source code)
##### - Guess first, and then run this program and see the result for yourself.
##### - What happens if you remove (byte) or (short)? Can you explain why?
##### - What happens if you remove (long)? Can you explain why?

#### **`03-3. Divisions >`**

##### * What will be printed on the display when you execute this program? (Refer to source code)
##### - Guess first, and then run this program and see the results for yourself.

#### **`03-4. Relational Operators >`**

##### * What will be printed on the display when you execute this program? (Refer to source code)
##### - Guess first, and then run this program and see the result for yourself.
##### - What happens if you remove the part "n != 0" or "n == 0"? Try it.

#### **`03-5. Assignment Operators >`**

##### * What will be printed on the display when you execute this program? (Refer to source code)
##### - Guess first, and then run this program and see the results for yourself.

url: https://raw.githubusercontent.com/yoonBot/Computer-Science-and-Engineering/34a267a0f4debc2082d6ec11e289e4250019fb96/CSE3040: Java Programming/Programming Labs/Programming Lab #03/README.md


text:
# Composer Compile Plugin [![Build Status](https://travis-ci.com/civicrm/composer-compile-plugin.svg?branch=master)](https://travis-ci.com/civicrm/composer-compile-plugin)

The "Compile" plugin enables developers of PHP libraries to define free-form "compilation" tasks, such as:

* Converting SCSS to CSS
* Generating PHP wrappers based on an XML schema

For PHP site-builders who use these libraries, the compilation process is a seamless part of the regular download (`composer install`, etc).

This model is framework-agnostic and portable to many different environments.  It includes a permission mechanism to
address historical concerns about `composer` hooks and untrusted libraries.  It allows libraries to be managed in a
"clean" fashion, amenable to patching/forking and without comitting build-artifacts. It relies on no external services,
and it can be run locally (or anywhere that `composer` runs).

At time of writing, the integration-tests are passing on both `composer` v1.10 and v2.0-dev.

## More information

* [doc/site-build.md](doc/site-build.md): Managing the root package (for site-builders)
* [doc/tasks.md](doc/tasks.md): Working with tasks (for library developers)
* [doc/evaluation.md](doc/evaluation.md): Evaluate and compare against similar options
* [doc/develop.md](doc/develop.md): How to work with `composer-compile-plugin.git` (for plugin-development)

repository: demeritcowboy/composer-compile-plugin

repo_name: demeritcowboy/composer-compile-plugin


text:
# View Source Plugin

***Abandonment Notice:** I'm afraid I simply don't have the time to maintain my Grav themes and plugins. Those interested in taking over should refer to the ["Abandoned Resource Protocol"](https://learn.getgrav.org/17/advanced/grav-development#abandoned-resource-protoc). Feel free to fork and replace. So long, and thanks for all the fish.*

The **View Source** Plugin is for [Grav CMS](http://github.com/getgrav/grav) and allows you to display the raw header and Markdown for a given page

## Installation

Installing the View Source plugin can be done in one of two ways. The GPM (Grav Package Manager) installation method enables you to quickly and easily install the plugin with a simple terminal command, while the manual method enables you to do so via a zip file.

### GPM Installation (Preferred)

The simplest way to install this plugin is via the [Grav Package Manager (GPM)](http://learn.getgrav.org/advanced/grav-gpm) through your system's terminal (also called the command line).  From the root of your Grav install type:

    bin/gpm install view-source

This will install the View Source plugin into your `/user/plugins` directory within Grav. Its files can be found under `/your/site/grav/user/plugins/view-source`.

### Manual Installation

To install this plugin, just download the zip version of this repository and unzip it under `/your/site/grav/user/plugins`. Then, rename the folder to `view-source`. You can find these files on [GitHub](https://github.com/aaron-dalton/grav-plugin-view-source) or via [GetGrav.org](http://getgrav.org/downloads/plugins#extras).

You should now have all the plugin files under

    /your/site/grav/user/plugins/view-source

> NOTE: This plugin is a modular component for Grav which requires [Grav](http://github.com/getgrav/grav) and the [Error](https://github.com/getgrav/grav-plugin-error) and [Problems](https://github.com/getgrav/grav-plugin-problems) to operate.

## Configuration

Before configuring this plugin, you should copy the `user/plugins/view-source/view-source.yaml` to `user/config/plugins/view-source.yaml` and only edit that copy.

Here is the default configuration and an explanation of available options:

```yaml
enabled: true
header: true
header_interpolated: true
body: true
body_interpolated: true
```

* `enabled` lets you turn the plugin off entirely.

* The `header` and `body` fields tell the plugin which parts of the page users are allowed to view. If these are set to false, then the plugin returns a `403 FORBIDDEN` when the source is requested.

* The `header_interpolated` and `body_interpolated` let the user view the header and body after being processed by the various plugins. If `header` or `body` are set to false, then the accompanying `*_interpolated` is automatically set to false as well.

You can enable/disable permissions on a page-by-page basis by inserting something like the following in the front matter of the page in question:

```yaml
view-source:
  header: false
  body: false
```

This would fully disable viewing the source of that specific page. You can do this by taxonomy also by using the [Header by Taxonomy plugin](https://github.com/Perlkonig/grav-plugin-header-by-taxonomy).

## Usage

Once enabled, each page view is examined for a query string that contains the parameter `view-source`. If found and set to `interpolated` (e.g., `http://example.com/blog/post?view-source=interpolated`), then the mode is set to `interpolated`. Any other setting (including blank) will result in the mode being set to `original` (e.g., `http://example.com/blog/post?view-source=`).

The plugin will then return a `200 OK` response with a `Content Type` header of `text/plain` and the body containing the source code as described below.

### Original Mode

The returned header will be the front matter as it appears in the original Markdown file.

The body will be the Markdown itself as it appears in the original Markdown file.

### Interpolated Mode

The returned header will be a YAML dump of the page's header (which can be modified in various ways by plugins).

The returned body will *usually* be the Markdown after any other Markdown-editing plugins are run. You *should* get the Markdown—not rendered HTML. But this will depend on how the plugins accomplished their task. This plugin grabs the content after the `onPageContentRaw` event. See [the Grav lifecycle](https://learn.getgrav.org/plugins/grav-lifecycle) for more details, and let me know if it doesn't work as expected in certain cases.

repository: Perlkonig/grav-plugin-view-source

repo_name: Perlkonig/grav-plugin-view-source


text:
---
layout: post
category : lessons
tagline: ""
tags : [ember, ember-cli]
title: "Building an Application with Ember-CLI Part 1"
description: First part of a series on building an app with Ember-CLI.
author: mike_munroe
---
{% include JB/setup %}
**UPDATE** (05/16/2014): Bryan Cardarella from DockYard is working on a similar tutorial and he has gone a bit more in depth than I have. Rather than regurgitate similar coverage on our blog, head over and check out Bryan's [coverage of the same topic](http://reefpoints.dockyard.com/2014/05/07/building-an-ember-app-with-rails-part-1.html).

-----

You are new to Ember or might even be a novice and you keep hearing about this Ember-CLI thing.

##What is Ember-CLI?

Ember-CLI is command line platform for building Ember applications. At this time, it seems like the Ember core team is standing behind Ember-CLI as the standard, so we at greenfield have hitched our wagons onto Ember-CLI and have been enjoying the benefits of set file structure conventions and module based code that Ember-CLI provides.

Before we get into the process of building out that Books application, let's review what module based code will look like inside of the Ember-CLI structure. To do so, I will create a model with Ember syntax that does not use modules and then module based syntax.

Non module syntax -
{% highlight JavaScript %}
  App.Person = DS.Model.extend({
    firstName: DS.attr(),
    lastName: DS.attr(),
    birthday: DS.attr()
  });
{% endhighlight %}

Module syntax -
{% highlight JavaScript %}
  var Person = DS.Model.extend({
    firstName: DS.attr(),
    lastName: DS.attr(),
    birthday: DS.attr()
  });

  export default Person
{% endhighlight %}

For more information on how Ember-CLI provides support for module based syntax, head on over to the [Ember-CLI docs](http://iamstef.net/ember-cli/#using-modules).

##Building Our Application

1. Complete [Getting Started](http://iamstef.net/ember-cli/#getting-started) within Ember-CLI docs
2. At the end of step 1, you should have run `ember server` from your command line
3. Navigate to `localhost:4200` in your browser, you should see
![cli index page]({{ BASE_PATH }}/assets/images/cli-tutorial/welcome.png)

Join us in part 2, as we start building out some substance for our application.

The code for this [example project](https://github.com/greenfieldhq/ember-cli-books) can be found on the [greenfield Github page](https://github.com/greenfieldhq).

##Resources
If you found this post and followed along, you may be just beginning your journey to learn Ember.js. If that is the case, I would suggest checking out Code School's [Warmimg Up with Ember](https://www.codeschool.com/courses/warming-up-with-emberjs) course. Code School requires a monthly membership, but it's around $30 or so. I checked out the material when it was first released and think it might be the best shortcut for a beginner to pick up some Ember skills.

Code School put out an Ember screencast called [Soup to Bits: Warming Up with Ember](https://www.codeschool.com/code_tv/soup-to-bits-warming-up-with-ember). This books project is basically a port of what is taught during the screencast, but in Ember-CLI.


text:
---
title: OpenTelemetry, The Missing Ingredient
excerpt: At its core, OpenTelemetry (OTel) is a vendor-neutral standard for telemetry. But it also provides a complete end-to-end implementation for generating, emitting, collecting, processing and exporting telemetry data to any support observability back-end.
date: 2022-10-16
permalink: /opentelemetry/
categories:
  - Support
tags: [OpenTelemetry, Observability]
---

- [Part 1: The Modern Observability Problem](/opentelemetry-observability)
- Part 2: OpenTelemetry, The Missing Ingredient

----------------------------
<br/>

In [Part 1](/opentelemetry-observability), we looked at the observability challenges for modern systems - microservices, composable architectures, event-driven, shared components - all that good stuff solving problems well. But they're really hard to support. We emphasised the importance of the right data being instrumented and we concluded that there are many good observability solutions, both open-source and commercial. But they all do things their own way, greatly reducing our ability to flex and adapt - letting our old opponent vendor lock-in through the door.

![image-center](/assets/images/opentelemetry/otel.png){: .align-center}

In this article, we'll look at how OpenTelemetry bridges the gap between our code and the observability backend options, supporting a **move away from vendor-specific tooling** for generating and exporting telemetry data.

## A Quick Refresher

Before we get started, let's refresh our terminology from [Part 1](/opentelemetry-observability):

![image-center](/assets/images/opentelemetry/refresher.png){: .align-right}

- **Instrumentation** is what produces the telemetry. When we talk about instrumenting, we mean to add libraries and/or code to our applications to collect telemetry such as logs, metrics and traces.
- **Telemetry** are insights into the behaviour or inner workings of a system – the data that the system emits about what’s happening inside the ‘black box’, collected via instrumentation. You may also hear these being called signals.

## A Vendor-Neutral Standard

At its core, OpenTelemetry (OTel) is a vendor-neutral standard for telemetry across languages. You only need to instrument your code once and can then easily change to other observability backends when your needs change.

It is also means you can stick with your backend of choice while being able to change the language you use - all supported languages will adhere to the same API specification for instrumentation.

## More Than A Vendor-Neutral Standard

OTel also provides **a complete end-to-end implementation** for generating, emitting, collecting, processing and exporting telemetry data to any supported observability back-end. For each language currently supported there core libraries, automatic instrumentation libraries, and exporters.

![image-center](/assets/images/opentelemetry/otel-libs.png){: .align-center}

### Core libraries

**The API** is the bare bones interface for instrumentation - no actual telemetry data will be sent to a backend. It's been done this way because third party libraries wishing to instrument their code should not need to be concerned with how the consuming application implements its OpenTelemetry.

**The SDK** is the complete language library that provides implementations of the API so we can instrument our code manually. It is what we pull directly into our applications. It doesn't implement exporters, which are separate libraries that take a dependency on the SDK. Alternative instrumentation are available in separate libraries implementing the API.

![image-center](/assets/images/opentelemetry/sdk2.png){: .align-center}

Typically, any application that we wish to hook up to a observability backend with OTel will take dependencies on both of these indirectly, through dependencies on instrumentation libraries and exporters.

### Instrumentation Libraries

Plugin-and-go for many common libraries and frameworks, such as those for web and databases. For example, we can generate telemetry data automatically for ASP.NET Core incoming web requests and outgoing Entity Framework requests. The only steps required are adding the two packages:

- OpenTelemetry.Instrumentation.AspNetCore
- OpenTelemetry.Contrib.Instrumentation.EntityFrameworkCore

 And adding them as services in code:

 ```csharp
 public void ConfigureServices(IServiceCollection services)
{
    services.AddOpenTelemetryTracing((builder) => builder
        .AddAspNetCoreInstrumentation()
        .AddEntityFrameworkCoreInstrumentation()
        // Add your exporter(s) here
    );
}
 ```

The OTel project maintains instrumentation and exporter packages for key OSS projects and compliance with the OTel specification, in its main repository for each language. For .NET this is [open-telemetry/opentelemetry-dotnet](https://github.com/open-telemetry/opentelemetry-dotnet/tree/main/src). Many others are then available from a sister contrib repository, which for .NET is [open-telemetry/opentelemetry-dotnet-contrib](https://github.com/open-telemetry/opentelemetry-dotnet-contrib).

### Exporters

Exporters are libraries to send the instrumented telemetry data to backends. This can be through the OpenTelemetry Protocol (OTLP) itself - and that is the long-term goal**\***, or vendor-specific such as Jaegar or Azure Monitor, where the exporter library would translate from the OpenTelemetry data in memory, to the format used by a vendor tool. The availability of these types of exporters makes it much easier to plan and execute a transition to OTLP.

**\***Vendors are increasingly offering full support for direct ingress of native OTLP. See [this list](https://opentelemetry.io/vendors/) for updates. The Jaeger docs now even state:

> As of 2022, the Jaeger SDKs are no longer supported, and all users are advised to migrate to OpenTelemetry.

## Vendor-Neutral Tracing

One of the biggest challenges I've faced when debugging distributed systems is getting visibility the complete end-to-end journey of a transaction through all the services involved.

In [part 1](/opentelemetry-observability) we introduced distributed tracing as a key part of any observability solution to solve just this problem. We acknowledged that there are many open-source and commercial products that do this already by propagating a trace ID between all operations in a transaction to tie everything together.

But more often than not, we end up with an incomplete picture that the business just accept as a risk, despite the increased effort for support. Some common causes of this include:

- Services on mixed tech stacks require different solutions and resource constraints prevent us from instrumenting all of them
- Vendor lock-in, where our chosen backend does not support the tech stack of some of our services
- Clients and agents to instrument and send telemetry are built in-house and resource constraints prevent us from maintaining them for all service tech stacks

![image-center](/assets/images/opentelemetry/missing-id.png){: .align-center}

As a single standard for tech stacks and backends, OTel eliminates these challenges. It brings a complete set of tools that really do simply plug in, to greatly reduce the resourcing required, and because it is an open standard, very little resources are required to switch to (or add) other backends.

### How OpenTelemetry Does Tracing

OTel represents each operation in a trace across a system with the concept of a **span**. Amongst other things [defined in the OTel specification](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/overview.md#spans), each span will hold:

- A unique trace ID for the whole 'journey' of the current transaction through the system
- A unique ID for the span itself
- A unique ID for the parent span so we can reconstruct the journey in an observability backend

![image-center](/assets/images/opentelemetry/sendspans.png){: .align-center}

Each span represents a single operation in the overall transaction through a system. Most backends will represent these against time, in a way you might be familiar with from [Gantt charts](https://en.wikipedia.org/wiki/Gantt_chart).

![image-center](/assets/images/opentelemetry/chart.png){: .align-center}

In this simplified example:

1. **Span A**: request comes into Service A for user details. This is the **root span** and of course, parent to **span B**. Most mainstream web frameworks will be able to auto-instrument this, meaning it will automatically create a trace span for this incoming request.
2. **Span B**:Service A calls Service B to get a user's details. We might get this from a library to auto-instrument HTTP calls or we could manually add a trace signal 'around' the code that makes the call.
3. **Span C**: Service B receives the request.
4. **Span D**: Inside the code to handle the request, a child span represents an SQL query to the database for the user details.
5. **Span E**: We manually instrument a signal for adding then user if it is not found.
6. **Span F**: Service B has returned the user details and Service A returns that data to the caller, which is auto-instrumented by our web framework.

## Vendor-Neutral Context Propagation

OTel uses the concept of **baggage**, which standardises the format of a shared context for values across programming languages and platforms, removing the need for teams to develop their own custom solutions for propagating shared data.

For example, if only `service A` sees a user's ID, we could put in the baggage so that `service B` could access in when called as a child/dependency.

![image-center](/assets/images/opentelemetry/baggage.png){: .align-center}

## The Collector: A Vendor-Neutral Proxy

The star of the show in my opinion, is the **collector**. While most languages have exporters to send telemetry data directly to back-ends, which is fine during development, it is beneficial to offload data quickly to a collector to handle the resource intensive tasks, such as:

- Exporting to multiple places
- Enhancing with metadata
- Batching
- Encryption
- Buffering and retries when the back-ends are unresponsive
- Control flow to back-ends to allow service to continue its work

The collector can receive and export data in multiple formats, to and from observability tools using the OpenTelemetry Procotol (OTLP) and proprietary ones. It does his by acting as a **pipeline** through receivers, processors and exporters.

![image-center](/assets/images/opentelemetry/pipeline.png){: .align-center}

### Receivers

Receivers are how telemetry signals are ingressed from sources into the collector before being processed and sent on to observability backends.

The core receiver is for telemetry using OTLP but there are many more available from the [contrib repository](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver) to support vendor formats and translate these to OTLP:

- A [file log receiver](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/filelogreceiver) that will tail and parse logs from files.
- A [Jaeger Receiver](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/jaegerreceiver), if you have an existing services exporting traces to Jaegar, these can be redirected to your collector and exported to new backends alongside the existing Jaegar instance.
- A [Kubernetes cluster receiver](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/k8sclusterreceiver) that collects cluster-level metrics from the k8s API server.

### Processors

Processors can be run on data between receiving and exporting. Some examples:

- A [redaction processor](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/processor/redactionprocessor) that can be configured to prevent sensitive information leaking into traces.
- A [k8s attributes processor](https://pkg.go.dev/github.com/open-telemetry/opentelemetry-collector-contrib/processor/k8sattributesprocessor)  that can automatically tag telemetry passing through the collector with k8s metadata.
- A [batch processor](https://github.com/open-telemetry/opentelemetry-collector/tree/main/processor/batchprocessor) to reduce the number of outgoing connections used to transmit to backends.

### Exporters

Similar to the libraries used directly by applications, these are used to send data to observability backends or other destinations from the collector.

As well as the core OTLP exporter, there are many available from the [contrib repository](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/exporter)

### The Sidecar Pattern

Below is a snapshot of a typical use-case. We have a .NET web app exporting logs, metrics and traces using OTLP to a collector. It also shows how we might choose to transition while continuing to output file logs, pulling them into the collector using the [file log receiver](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/receiver/filelogreceiver).

This method of deployment depicted is where a collector is deployed alongside each service on a one-to-one basis, with a shared lifetime with the service. This tends to put ownership of the collector with the development team(s) and is useful if you need to do processing specific to a service.

![image-center](/assets/images/opentelemetry/collector2.png){: .align-center}

Our collector could then be setup as a pipeline to export those to the back-ends of our choosing.

The configuration for that pipeline would like this ([complete config file](https://gist.github.com/benbhall/04b3ec79b6a1934be586efbf06a0ef21)):

```yaml
service:
  pipelines:
    traces:
      receivers: [otlp]
      exporters: [otlp, elasticsearch/trace]
    logs:
      receivers: [otlp]
      exporters: [otlp, elasticsearch/log, file/rotation_with_default_settings]
    metrics:
      receivers: [otlp]
      exporters: [otlp, prometheus]
```

### As a Single Gateway

It's also possible to deploy the collector as standalone **gateway** component, to be scaled independently of the services. This tends to mean ownership of the collector is with platform teams who can then centrally manage policies and permission.

![image-center](/assets/images/opentelemetry/collector1.png){: .align-center}

The ideal setup is for each service or collection of services to have dedicated collectors as agents, owned by the development team. These would export to an instance run as a gateway by the ops teams to apply their own processes such as authentication or metadata.

## Summary

Observability solutions, both open-source and commercial, have done a good job in catching up with the demands of supporting complex modern architectures. The big unsolved problem was the lack of standards, which reduced our ability to flex and adapt, resulting in some level of vendor lock-in.

OpenTelemetry is the missing ingredient, which is set to change the landscape significantly. It is very easy to adopt with a real plug-and-play feel to it, and there is good transition support with libraries to translate between proprietary protocols and OpenTelemetry.

For the .NET readers, [fire up my demo repository](https://github.com/benbhall/opentelemetry-demo) and have a go at using OpenTelemetry with .NET and Azure Monitor.

**EDIT April 2023**: Listen to me on the Day Two Cloud, a Packet Pushers podcast, talking about OpenTelemetry. [Use this direct link](https://packetpushers.net/podcast/day-two-cloud-192-opentelemetry-getting-from-visibility-to-observability-with-ben-hall/) or listen on your favourite podcast platform via [pod.link](https://pod.link/1460004936/episode/20e545a2b4fd8e48142eb4a23e67d4ce).

gha_language: SCSS


text:
ContentMine Workshop at the University of Bath
==============

![ContentMine logo](https://github.com/ContentMine/ebi_workshop_20141006/raw/master/setup/CM_logo.png)

## Information about the event [here] (http://www.eventbrite.com/e/text-data-mining-for-biologists-registration-17603659018)

#### Location: Room 3.7, Building 3 West, University of Bath

|28th July 2015          |
:---------------:         |
|Training Workshop      |
|10:00 - 17:30          |

##  \#BathMining
Contact us via [@TheContentMine] (https://twitter.com/TheContentMine) or<EMAIL_ADDRESS>

### Trainers:

- Ross Mounce [@rmounce](https://twitter.com/rmounce)
- Peter Murray-Rust [@petermurrayrust](https://twitter.com/petermurrayrust)
- The ContentMine Team [@TheContentMine] (https://twitter.com/TheContentMine)

### Please read the [Pre-workshop Installation Instructions] (https://github.com/ContentMine/workshop-resources/blob/master/software-tutorials/vms/README.md)

### Workshop Purpose
Content mining technologies hold much potential for maximising discovery and reuse of research as well as generating novel scientific discoveries through automatedly searching, indexing and analysing the scientific literature.

This workshop aims to educate and engage researchers and research-related professionals in the UK who are interested in using these technologies for their work in the biological sciences. In turn this will help to provide demonstrable examples of the benefits of content mining.

Participants will be instructed in use and custom development of tools in the ContentMine pipeline before having the opportunity to apply these skills for their own needs.

### Workshop Objectives
1. Raise awareness of content mining among researchers.
2. Train 20-25 researchers in using the ContentMine pipeline tools.
3. Promote legal and responsible content mining practices.

### Anticipated Workshop Outcomes
1. Research or assessment performed using ContentMine tools by a proportion of workshop participants.
2. Production of new journal scraper definitions.
3. Continuing collaboration with participants and the ContentMine project.
4. One or more ContentMine trainers recruited from pool of participants, increasing the reach of training for content mining.

### Intended Audience

This one day event is intended for researchers or research-related staff who are not currently heavily involved in text and data mining but have at least some pre-existing computational skills. At minimum we expect familiarity with a command line interface. Experienced developers are also extremely welcome. We expect participants to be researchers working in the fields of life science and biomedicine. All our examples and activities will therefore be geared to biological and biomedical sciences. Open Access content in the Europe PMC repository will be the primary source material for this workshop.

### Training Workshop Agenda
| Times           | Session                 |
| ----            | -------                 |
|10:00      |**Introductions**            |
|10:10      |**What is content mining?**

Overview presentation from Ross Mounce

|
|10:30      |**Think like a content miner**

Hands-on activity facilitated by the ContentMine trainers introducing entity extraction techniques, precision and recall.

|
|11:00      |**Introducing getpapers**

Introducing the handy `getpapers` tool for mining open access content

|
|11:45      |**Scraping and the anatomy of scrapers**

Hands-on activity facilitated by the ContentMine trainers including use of quickscrape and custom scraper development.

|
|13:00      |**Lunch**|
|14:00      |**Entity recognition using AMI**

Hands-on activity facilitated by ContentMine trainers  including extracting species names from OA papers using AMI-species.

|
|15:00      |**Introduction to regular expressions and AMI-regex**

Hands-on activity facilitated by ContentMine trainers  including regex creation in groups and use of AMI-regex.

|
|15:30      |**Legality of content mining: what can I mine?**

 Presentation and Q&A by ContentMine trainers covering copyright, database and contract law. Special attention will be paid to the UK copyright exception

|
|16:00    |**Working on your own use cases**

Time to work on your own use-cases with expert help on hand.

|
|17:30 onwards|**Informal social event**

Move as a group to nearby student union bar for drinks and discussion.

### Documentation

The primary means of communication and taking notes during the workshop will be via this [Etherpad] (http://pads.cottagelabs.com/p/contentmine_bath).

If you're not familiar with Etherpads, it's easy - you just type! Your writing will show up in a different colour to other people's and you can associate the colour with your name by clicking the person icon in the top right corner of the screen.

## Click [here](https://groups.google.com/d/forum/contentmine-workshops) to be advised of future ContentMine Workshops


text:
XBMC Xbox HID Controller
========================

Control XBMC using an original Xbox controller on OS X

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

### Dependencies

Install the necessary dependencies

- Install [XCode][0] or have `xcodebuild` available in your `$PATH`
- Install the [Xbox HID controller][1] driver1

---

1 If you are running Mountain Lion, Mavericks, or higher, you will
need to install the latest version of this driver found in [this
blog post][2] by using this direct link
[http://xhd.cvs.sourceforge.net/viewvc/xhd/xhd/Release/xhd_2_0_0.dmg?revision=1.3.](http://xhd.cvs.sourceforge.net/viewvc/xhd/xhd/Release/xhd_2_0_0.dmg?revision=1.3)

---

### Compile and Intsall

Install this program by running

    git clone git://github.com/bahamas10/XBMCXboxHIDController.git
    cd XBMCXboxHIDController
    make
    sudo make install

How To
------

After you have followed the above installation steps, you can call the program
directly by running

    $ XBMCXboxHIDController
    analog deadzone of 30%
    sending events to <IP_ADDRESS>:9777
    starting, ctrl-c to exit
    ^C

All events generated by the controller will be forwarded to XBMC over `UDP://<IP_ADDRESS>:9777`
(the EventServer API) and will conform to `gamepad.xml` found in `keymaps/` of XBMC.

Note that events will only be forwarded if an app by the name of `XBMC` currently has
focus.  When `XBMC` becomes inactive, no events are sent over UDP.  This behavior
can be overridden by supplying the `-a` switch.

Add `-v` to log every controller connection/disconnection and each UDP packet sent

    $ XBMCXboxHIDController -v
    analog deadzone of 30%
    sending events to <IP_ADDRESS>:9777
    starting, ctrl-c to exit
    controller detected
    {button: dpadup, map: XG, down: 1, }
    {button: dpadup, map: XG, down: 0, }
    {button: dpaddown, map: XG, down: 1, }
    {button: dpaddown, map: XG, down: 0, }
    {button: B, map: XG, down: 1, }
    {button: B, map: XG, down: 0, }
    {button: white, map: XG, down: 1, }
    {button: white, map: XG, down: 0, }
    {button: black, map: XG, down: 1, }
    {button: black, map: XG, down: 0, }
    {button: back, map: XG, down: 1, }
    {button: back, map: XG, down: 0, }
    {button: A, map: XG, down: 1, }
    {button: A, map: XG, down: 0, }
    {amount: 6656, down: 1, map: XG, button: rightanalogtrigger, }
    {amount: 7680, down: 1, map: XG, button: rightanalogtrigger, }
    {amount: 8448, down: 1, map: XG, button: rightanalogtrigger, }
    {amount: 9984, down: 1, map: XG, button: rightanalogtrigger, }
    {amount: 10752, down: 1, map: XG, button: rightanalogtrigger, }
    {amount: 12288, down: 1, map: XG, button: rightanalogtrigger, }
    {amount: 13056, down: 1, map: XG, button: rightanalogtrigger, }
    {amount: 14336, down: 1, map: XG, button: rightanalogtrigger, }
    {amount: 14592, down: 1, map: XG, button: rightanalogtrigger, }
    {amount: 15104, down: 1, map: XG, button: rightanalogtrigger, }
    ^C

Usage
-----

    $ XBMCXboxHIDController -h
    usage: XBMCXboxHIDController

    control XBMC using an original Xbox controller

    options
      -a              always send events, default is to only send events when XBMC has the foreground
      -d <deadzone>   deadzone percentage for analog sicks, defaults to 30
      -h              print this message and exit
      -H <host>       host on which to listen, defaults to <IP_ADDRESS>
      -p <port>       port on which to listen, defaults to 9777
      -v              enable verbose logging

License
-------

MIT License

[0]: https://itunes.apple.com/us/app/xcode/id497799835
[1]: http://xhd.sourceforge.net/
[2]: http://macman860.wordpress.com/2013/05/03/xbox-driver-for-mac-os-x-lion/

repository: vrudikov/XBMCXboxHIDController

repo_name: vrudikov/XBMCXboxHIDController


text:
# E-mail Spam Status Scanner

Written in Python, this terminal based application performs a GET request to **cleantalk.org** with the e-mail you've provided to check against spam recordings. Enjoy!!!
> It's worth noting that the cleantalk API will not allow infinite data lookups per day without a paid license.

## How to install:
```
sudo apt-get install python3
```

```
sudo apt-get install pip
```

```
pip install requests
```

```
pip install bs4
```

## How to operate:
1. Navigate to the application's working directory
```
python3 app.py
```

> Use freely & responsibly.


text:
# Series V

Write a program to generate the first 'n' terms of the
following series 121, 225, 361,...

### INPUT & OUTPUT FORMAT:

The input is an integer 'n' which denotes the number of
terms to be printed in the series.

Print the series and refer the sample output for formatting.

### SAMPLE INPUT 1:

```
4
```

### SAMPLE OUTPUT 1:

```
121 225 361 529
```

### SAMPLE INPUT 2:

```
5
```

### SAMPLE OUTPUT 2:

```
121 225 361 529 729
```

### SAMPLE INPUT 3:

```
3
```

### SAMPLE OUTPUT 3:

```
121 225 361
```

repository: KamalDGRT/ProgrammingPractice

repo_name: KamalDGRT/ProgrammingPractice


text:
# KozHash
 A String to Hash function library for use with the Ark Dev Kit. Also includes test map, PGD, and singleton wired up to run hashing tests in the editor.

## Contents
- _KozHash
  - _KozHash_Func
    - _the hash function library_
  - KozHashTestActor
    - _testing singleton_
  - PrimalGameData_BP_KozHashTest
    - _test PGD_
  - TestMapArea_KozHashTest
    - _test map level_
- TestLog_30CharMax_500TestPerAlpha.txt
  - _PIE log from tests w/ 30 char max len random strings & 500 hash tests per alphabet_
- TestLog_500CharMax_50TestPerAlpha.txt
  - _PIE log from tests w/ 500 char max len random strings & 50 hash tests per alphabet_

## Functions in _KozHash_Func
- **KozHash StringToHash**
  - _this is the main hash function, give string, get int32 hash_
- KozHash ShortPad
  - _used for strings w/ len < 7_
  - _pads right until string is len 7_
  - _pads using char derived from avg of all str ascii codes_
- KozHash FindPrimeLen
  - _finds the next prime string length, if not already prime_
  - _forces min len of 7_
- KozHash TruePow
  - _gives true binary value for 2^0 -> 2^31_
  - _Exp parm clamped to 0-31_
- KozHash BitShift
  - _performs 'bit shift' on int value for specified count # positions_
  - _positive count shifts left_ `<<` _bits fall off left, zeros fill on right_
  - _negative count shifts right_ `>>` _bits fall off right, zeros fill on left_

## Hash Logic / Algorithm
1. Is short string? (<7 length)
  - _String is right padded until length==7_
  - _Pad Char is AVG of all string char ascii codes, used as ascii code for char_
2. Is string length NOT prime?
  - _Next prime value found (ex. len 8 -> 11)_
  - _String is padded until matches prime length_
  - _Pad char is static ascii code chosen for its bit pattern_ `213 / 0xD5 / 1101 0101`
3. Bit operations done per character in string
  - _h is the output value, the hash, initialized to 0 at start_
  - _ki is the current char ascii in string/loop_
  - _ascii codes > 255 are split into their two byte values and then the below is run on each, low byte first_
```
//  CRC Variant Hash Algorithm  // (yes it is simple)
h = 0                           // init
... start char loop ...
highorder = h & 0xf8000000      // set 5 high bits aside
h = h << 5                      // bit shift left, removing 5 high bits
h = h ^ (highorder >> 27)       // shift those 5 high bits we set aside to
                                // right 27 which makes them the low bits
                                // then XOR that with h
h = h ^ ki                      // XOR h with current char ascii ki
... end char loop ...
```
4. Were any unicode chars encountered? (ascii > 255)
  - _Count of unicode encountered is added to string length and prime checked same as initially_
  - _new prime length diffed against old, this is how many pad chars we will add to calculation_
  - _this is done to ensure the 'set' operated on is always prime length and unicode added items to set_
  - _pad char ascii used for this is_ `21 / 0x15 / 0001 0101`
5. Final 'h' from above is hash returned

## Collision Testing
I have run the tests provided in this repo many times, resulting in 10s of thousands of hash collision tests overall. The core CRC Variant algorithm has not changed since I began the testing, however, the padding strategies I have implemented are there as mitigating factors for collisions I found to occur on short strings.

If you find any collisions please do reach out to me and let me know what the strings and colliding hash value were.  Thanks!

- Discord: Koz#4354 / https://discord.gg/FmWBgQV
- Steam: Kozenomenon / https://steamcommunity.com/profiles/76561197962912863/

## Reference
I got the CRC Variant hash algorithm from this site. Yes, it is old and simple, but simple was also kind of the idea... :D
https://www.cs.hmc.edu/~geoff/classes/hmc.cs070.200101/homework10/hashfuncs.html

repository: Kozenomenon/KozHash

repo_name: Kozenomenon/KozHash


text:
---
title: Telerik.Web.UI.Diagram.Gradient
page_title: Telerik.Web.UI.Diagram.Gradient
description: Telerik.Web.UI.Diagram.Gradient
---

# Telerik.Web.UI.Diagram.Gradient

Defines the gradient fill of the shape.

## Inheritance Hierarchy

* System.Object
* Telerik.Web.StateManager : IMarkableStateManager, IStateManager
* Telerik.Web.UI.Diagram.Gradient : IDefaultCheck

## Properties

###  Center `Object[]`

The center of the radial gradient.Coordinates are relative to the shape bounding box. For example [0, 0] is top left and [1, 1] is bottom right.

###  End `Object[]`

The end point of the linear gradient.Coordinates are relative to the shape bounding box. For example [0, 0] is top left and [1, 1] is bottom right.

###  Radius `Double`

The radius of the radial gradient relative to the shape bounding box.

###  Start `Object[]`

The start point of the linear gradient.Coordinates are relative to the shape bounding box. For example [0, 0] is top left and [1, 1] is bottom right.

###  StopsCollection `DiagramGradientStopsCollection`

The array of gradient color stops.

###  Type `GradientType`

Define the type of the gradient.

repository: telerik/ajax-docs

gha_language: C#

repo_name: telerik/ajax-docs