text:
## ReactJS DEVPLENO

# MERCADO DEV
This project is part of DevPleno's ReactJS course.

Using:
 - React
 - Firebase Database
 - Firebase Storage (Upload and Download of Images)

## Screens
![screen](../master/home_01.png)

![screen](../master/home_02.png)

## License

    Copyright 2018 Tobias Andre Eggers

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

        http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.

repository: TobiasAndre/MercadoDev

repo_name: TobiasAndre/MercadoDev


text:
<!-- README.md is generated from README.Rmd. Please edit that file -->

# Exploratory Data Analysis

<!-- badges: start -->

[![Lifecycle:
Experimental](https://img.shields.io/badge/lifecycle-experimental-orange.svg)](https://www.tidyverse.org/lifecycle/#experimental)
[![Project Status:
WIP](https://www.repostatus.org/badges/latest/wip.svg)](http://www.repostatus.org/#wip)
<!-- badges: end -->

## General Overview

The goal of **EDA** is to:

  - Save Time
  - Improve Efficiency
  - Improve Project Analysis Quality
  - Priduce Artifacts for Export Internally and Externally to Excel,
    PowerPoint, and Word

## Installation

> Since **EDA** is a private repository make sure you have a GitHub
> PAT (personal access token) setup and have permission before
> attempting to install the package. See [Usethis Setup
> Guide](https://usethis.r-lib.org/articles/articles/usethis-setup.html#get-and-store-a-github-personal-access-token)
> for more details on setting this up.

You can install from [GitHub](https://github.com/) with:

``` r
remotes::install_github("jimbrig2011/EDA")

# or

require(devtools)
devtools::install_github("jimbrig2011/EDA")
```

## Run Application

After installing the package, you can run the app simply with:

``` r
EDA::run_app()
```

## Roadmap

**EDA** desires to provide the following features:

  - Data Upload Management:

      - Support easy data upload for a various number of possible data
        types (xlsx, csv, txt, etc).
      - Support advanced settings to upload different types of data
        (i.e. merge across excel tabs, headers, lines to skip, etc.)
      - Implement a “control totals” feature which allows user to
        preview the sums of numeric columns and validate / reconcile.
      - Allow user to create their own datasets from uploaded files via
        merging and transforming them
      - Provide initial summary statistics on data and preview data
        itself

  - Data Diagnostics

  - Data Dictionary

  - Data Validation Report

  - Data Summaries

  - Data Visualization

  - Export to PDF, PowerPoint, CSV, Excel, and Email

  - Multivariate Analysis

  - Feature Engineering / Variable Importance

  - Record Linkage

license: MIT

repository: ScottSobel/EDA

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: ScottSobel/EDA


text:
# ActionNetwork.JS

JS helpers for [the Action Network activist CRM platform](https://actionnetwork.org).

Still a work-in-progress!

## Simple usage example

```html
<script src="action-network.js/dist/action-network.js"></script>
<link rel = "stylesheet" type="text/css" href="action-network.js/dist/action-network.css" />

<form data-tags="general-signup" data-autoresponder="true" data-form="[Your form ID]">
  <div class="success-msg hidden">
    Thank you for your interest in our organization!
  </div>
  <input type="email" name="email" placeholder="Your email address" />
  <button type="submit">Sign up</button>
</form>
```

More docs soon!

gha_language: JavaScript

gha_license_id: MIT


text:
#Tribe Hackers Challenge 2

 Uses:

-User keeps posting about how they want to move to a new neighborhood to grow a family, agent uses information to find the right scenery for the user

-User complains how the rent/monthly payments should give a better household. The agent may use information to find a home in better condition for equal to or less than the price of the current user's house

-User posts about finding an apartment that he/she could possibly split the price with. Agent then has the information needed to find possible homes that others are in need of a roommate/housemate

-User says he wants a specific car brand, but thinks that it will be too expensive. Agent can use this information to possible get a more affordable car of that brand for possible lease and/or used

-User does not know how to sell his/her home, they have been posting about how it is up for sale but there are no buyers. Agent picks up on this and contacts the right personel that may be looking to buy a home of that specific price range and/or that location

-User posts about how they are planning on working somewhere away from their hometown but do not know how to find a new place to live (college graduate). Agent is prompted by this and can help the user to find a suitable new home to start their career.

-
Licenses:
-MIT License:

Copyright (c) [year] [fullname]

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

 IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

How to implement:
Create a text file (typically named LICENSE or LICENSE.txt) in the root of your source code and copy the text of the license into the file. Replace [year] with the current year and [fullname] with the name (or names) of the copyright holders.

Optional: Add MIT to your project's package description, if applicable (e.g., Node.js, Ruby, and Rust). This will ensure the license is displayed in package directories.

gha_language: Python


text:
---
id: cli-doctor
title: Doctor
---

Diagnose a bit workspace.

## Synopsis

```bash
bit doctor [-j|--json] [-s|--save] [--list]
```

## Examples

### Run all checks on a workspace

In case you have an error in any of your commands, run a full diagnosis on the workspace. If any issues are found, a set of instructions to resolve them are presented.

```bash
bit doctor
```

### Save workspace state to reproduce an issue

Bundle all the workspace alongside Bit's logs and state and prepare it to send to the maintainers for debug.

```bash
bit doctor --save doctor-output
```

repository: jpbow/docs

gha_license_id: NOASSERTION

repo_name: jpbow/docs


text:
# Bot-Potaha

An Discord Bot using Eris library by abalabahaha

How to install?

You must have Node.JS

Install Eris by abalabahaha using npm i eris

Edit runbot.js, i mean change "tokerino here" to your bot token, explained below.

Start your bot using node runbot.js

Now to configurate it

Open erissettings.json

Meanings of the erissettings.json:

token = token of your discord bot. go here https://discordapp.com/developers/applications/me and click your bot, then click Reveal Token, then edit "replace dis" with your bot token that you just copied

prefix = prefix that will your bot respond. Example: "/" prefix, Usage: /help. like that

playing = playing status. you may know yourself what this means

oid = ownerid. Just click yourself, then click Copy ID. edit "replace dis" with your id.

osuApi = api of osu! game key. you can get the key here: https://osu.ppy.sh/p/api. you must log in/sign up first. then edit "replace dis" with your osu! key api.

repository: wkwkwkwkw/Bot-Potaha

repo_name: wkwkwkwkw/Bot-Potaha


text:
# CSP
`csp`: An abstract class of csp solvers. Used to solve n-queens and soduku.
* Forward checking
* Backpropagation

# Pacman AI
## Search
* Path finding
  * Depth first search, path checking
  * Breadth first search, full cycle checking
  * Uniform cost search
  * A star
* Corner problem
* Food heuristic for max reward

## multiagent
Implemented mini-max game tree with alpha beta pruning and expectimax

## tracking
Multi agent probabilistic Hidden Markov Model


text:
---
backdrop: images/1-nostairs-closest.png
---

# The West Wall

Walking west, you encounter thick underbrush. Vegetation has grown in close to the wall, and dangling vines whack your face as you push through.

As you move vines aside to pass, your hand brushes a carving embedded in the wall. It's another glyph.

<Item id="7" />

<Page url="398" instructions="Another puzzler. Your guidebook provides another clue: '3: The DOM is a ---- structure'." action="Walk south" condition="7" />

repository: jlooper/azure-maya-mystery

repo_name: jlooper/azure-maya-mystery


text:
[Back to Main Index](../README.md)

## Slack Resources
Here are some resource to familiarize yourself with common tasks you may encounter or need to know while using the Slack service.

* **[Create a snippet](https://get.slack.help/hc/en-us/articles/204145658-Create-a-snippet)**
* **[Customize your Slack theme](https://get.slack.help/hc/en-us/articles/205166337-Customize-your-Slack-theme)**
* **[Format messages](https://get.slack.help/hc/en-us/articles/202288908-Format-your-messages)**
* **[Emoji reactions](https://get.slack.help/hc/en-us/articles/206870317-Emoji-reactions)**
* **[Mention a member](https://get.slack.help/hc/en-us/articles/205240127-Mention-a-member)**
* **[How to Pin items](https://get.slack.help/hc/en-us/articles/205239997-Pin-messages-or-files)**
* **[Setting a reminder](https://get.slack.help/hc/en-us/articles/208423427-Set-a-reminder)**
* **[Share links in Slack](https://get.slack.help/hc/en-us/articles/204399343-Share-links-in-Slack)**

repository: treehouse-projects/python-resources

repo_name: treehouse-projects/python-resources


text:
# EKG

[![Build Status](https://travis-ci.org/bufferapp/EKG.svg?branch=master)](https://travis-ci.org/bufferapp/EKG)

EKG is a library for implementing Kubernetes [liveness and readiness](https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-probes/) probe handlers in a sidecar or in your application.

NOTE: This project was heavily influenced from [Heptio Healthcheck](https://github.com/heptiolabs/healthcheck). However EKG takes it a step further by providing a configurable sidecar. This means that for the most common healthcheck scenarios you don't need to instrument you application with code -- you can write the healthcheck configurations in YAML.

## Quickstart - Kubernetes

The fastest way to get up an running with EKG is to add a it as a sidecar in the Kubernetes deployment file.

```yaml
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: my-application
spec:
  replicas: 1
  template:
    metadata:
      labels:
        app: my-application
    spec:
      containers:
      - name: my-application
        image: my-org/my-application
        ports:
        - containerPort: 3000
      # add the sidecar
      - name: healthcheck
        image: bufferapp/ekg:0.1.2
        env:
        - name: EKG_CONFIG
          value: >
            {
              "port": 8086,
              "livenessChecks": [
                {
                  "name": "httpget-check-service",
                  "type": "httpGetCheck",
                  "url": "http://localhost:3000"
                }
              ],
              "readinessChecks": [
                {
                  "name": "dns-check-upstream",
                  "type": "dnsResolveCheck",
                  "host": "upstream.example.com"
                },
                {
                  "name": "mongodb-check-buffer",
                  "type": "mongoDBCheck",
                  "host": "mongo",
                  "port": 27017
                }
              ]
            }
         # define a liveness probe that checks every 5 seconds, starting after 5 seconds
        livenessProbe:
          httpGet:
            path: /live
            port: 8086
          initialDelaySeconds: 5
          periodSeconds: 5
        # define a readiness probe that checks every 5 seconds
        readinessProbe:
          httpGet:
            path: /ready
            port: 8086
          periodSeconds: 5
```

## Sidecar Config API

EKG sidecar is passed it's configuration as JSON through the EKG_CONFIG environment variable. It has the following configuration options:

```json
{
  "port": 8086,
  "livenessChecks": [
    {
      "name": "httpget-check-service",
      "type": "httpGetCheck",
      "url": "http://localhost:3000",
      "timeout": 5000
    },
    {
      "name": "dns-check-upstream",
      "type": "dnsResolveCheck",
      "host": "upstream.example.com",
      "timeout": 5000
    },
    {
      "name": "tcp-check-buffer",
      "type": "tcpDialCheck",
      "host": "buffer.com",
      "port": 80,
      "timeout": 5000
    },
    {
      "name": "mongodb-check-buffer",
      "type": "mongoDBCheck",
      "host": "mongo",
      "port": 27017,
      "timeout": 5000
    }
  ],
  "readinessChecks": [
    {
      "name": "httpget-check-service",
      "type": "httpGetCheck",
      "url": "http://localhost:3000",
      "timeout": 5000
    },
    {
      "name": "dns-check-upstream",
      "type": "dnsResolveCheck",
      "host": "upstream.example.com",
      "timeout": 5000
    },
    {
      "name": "tcp-check-buffer",
      "type": "tcpDialCheck",
      "host": "buffer.com",
      "port": 80,
      "timeout": 5000
    },
    {
      "name": "mongodb-check-buffer",
      "type": "mongoDBCheck",
      "host": "mongo",
      "port": 27017,
      "timeout": 5000
    }
  ]
}
```

### port

An integer specifying the port to serve the liveness and readiness probes.

### livenessChecks

A list of checks to perform when the `/live` endpoint is requested.

### readinessChecks

A list of checks to perform when the `/ready` endpoint is requested.

There are several types of checks that can be configured:

### Check Types

There are several different types of checks that can be configured. Each check is performed serially and in order. Both livenessChecks and readinessChecks can handle all configurable checks:

**httpGetCheck**

perform an HTTP get request against a url

```js
{
  "name": "httpget-check-service", //
  "type": "httpGetCheck",
  "url": "http://localhost:3000",
  "timeout": 5000
}
```

**dnsResolveCheck**

Do a DNS lookup on a host

```js
{
  "name": "dns-check-upstream",
  "type": "dnsResolveCheck",
  "host": "upstream.example.com",
  "timeout": 5000
}
```

**tcpDialCheck**

Attempt to establish a TCP socket connection

```js
{
  "name": "tcp-check-buffer",
  "type": "tcpDialCheck",
  "host": "buffer.com",
  "port": 80,
  "timeout": 5000
}
```

**mongoDBCheck**

Ping a mongodb database

```js
{
  "name": "mongodb-check-buffer",
  "type": "mongoDBCheck",
  "host": "mongo",
  "port": 27017,
  "timeout": 5000
}
```

### Secrets

You might want configure a healthcheck on a public repository with a URL that could be considered sensitive. EKG can plug environment variables into the EKG_CONFIG environment for this type of information:

```yaml
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: my-application
spec:
  replicas: 1
  template:
    metadata:
      labels:
        app: my-application
    spec:
      containers:
      - name: my-application
        image: my-org/my-application
        ports:
        - containerPort: 3000
      # add the sidecar
      - name: healthcheck
        image: bufferapp/ekg:0.1.2
        env:
        # my super secret MongoDB host
        - name: MONGO_HOST
          valueFrom:
            secretKeyRef:
              key: mongo-host
              name: my-application-secrets
        # my super secret MongoDB port
        - name: MONGO_PORT
          valueFrom:
            secretKeyRef:
              key: mongo-port
              name: my-application-secrets
        - name: EKG_CONFIG
          value: >
            {
              "port": 8086,
              "livenessChecks": [
                {
                  "name": "httpget-check-service",
                  "type": "httpGetCheck",
                  "url": "http://localhost:3000"
                }
              ],
              "readinessChecks": [
                {
                  "name": "dns-check-upstream",
                  "type": "dnsResolveCheck",
                  "host": "upstream.example.com"
                },
                {
                  "name": "mongodb-check-buffer",
                  "type": "mongoDBCheck",
                  # Plug in mongo secrets
                  "host": "${MONGO_HOST}",
                  "port": ${MONGO_PORT}
                }
              ]
            }
         # define a liveness probe that checks every 5 seconds, starting after 5 seconds
        livenessProbe:
          httpGet:
            path: /live
            port: 8086
          initialDelaySeconds: 5
          periodSeconds: 5
        # define a readiness probe that checks every 5 seconds
        readinessProbe:
          httpGet:
            path: /ready
            port: 8086
          periodSeconds: 5
```

## Quickstart - Manual

If you don't want to use a sidecar or have some custom liveness checks you'd like to perform, this is the better option. The easiest way to get going is to add some checks and listen on a port the main application is not using.

EKG is an NPM package for Node applications. Add it as a dependency to your package.json:

```bash
npm i -S @bufferapp/ekg
```

Instrument EKG into your app.

```js
const micro = require('micro')
const EKG = require('@bufferapp/ekg')

const mainServer = micro(() => 'OK')
mainServer.listen(3000, () => console.log('main - listening on port 3000'))

const ekg = new EKG()
// Liveness
ekg.addLivenessCheck({
  name: 'passing-live-check',
  check: async () => 'OK',
})

// Readiness
ekg.addReadinessCheck({
  name: 'passing-ready-check',
  check: async () => 'OK',
})

const ekgServer = micro(ekg.handler)
ekgServer.listen(3002, () => console.log('listening on port 3002'))
// go to http://localhost:3002/live or http://localhost:3002/ready
```

## API

```js
const EKG = require('@bufferapp/ekg')
// or with all the checks
const {
  default: EKG,
  httpGetCheck,
  dnsResolveCheck,
  tcpDialCheck,
  mongoDBCheck,
  timeoutCheck,
} = require('@bufferapp/ekg')
// or ES6
import EKG, {
  httpGetCheck,
  dnsResolveCheck,
  tcpDialCheck,
  mongoDBCheck,
  timeoutCheck,
} from '@bufferapp/ekg'
```

### EKG

Construct an EKG instance

```js
const ekg = new EKG()
```

The ekg instance exposes a few methods:

**addLivenessCheck**

Add a check to perform when the `/live` endpoint is called

```js
// with a custom check
ekg.addLivenessCheck({
  name: 'my-new-check',
  check: async () => 'OK',
})
// or with a pre-configured check
ekg.addLivenessCheck({
  name: 'my-new-check',
  check: httpGetCheck({
    url: 'http://localhost:3000',
    timeout: 5000,
  }),
})
```

**addReadinessCheck**

Add a check to perform when the `/ready` endpoint is called

```js
// with a custom check
ekg.addLivenessCheck({
  name: 'my-new-check',
  check: async () => 'OK',
})
// or with a pre-configured check
ekg.addLivenessCheck({
  name: 'my-new-check',
  check: httpGetCheck({
    url: 'http://localhost:3000',
    timeout: 5000,
  }),
})
```

**handler**

A function that handles requests and performs readiness and liveness checks

```js
// with micro
micro(ekg.handler)
// or express
app.get('*', async (req, res, next) => {
  try {
    await ekg.handler(req, res)
  } catch (err) {
    next(err)
  }
})
```

### httpGetCheck

Returns a function that does an HTTP get request on a URL

```js
const doCheck = httpGetCheck({
  url: 'http://localhost:3000',
  timeout: 5000,
})

doCheck()
```

### dnsResolveCheck

Returns a function does a DNS lookup on a host

```js
const doCheck = dnsResolveCheck({
  host: 'buffer.com',
  timeout: 5000,
})

doCheck()
```

### tcpDialCheck

Returns a function that creates and connects to a TCP socket

```js
const doCheck = tcpDialCheck({
  host: 'buffer.com',
  port: 80,
  timeout: 5000,
})

doCheck()
```

### mongoDBCheck

Returns a function that pings a mongodb database

```js
const doCheck = mongoDBCheck({
  host: 'mongo',
  port: 27017,
  timeout: 5000,
})

doCheck()
```

### timeoutCheck

Returns a function that runs a function and throws an exception if the function times out

```js
const doCheck = timeoutCheck({
  check: () =>
    new Promise(resolve => {
      // should always fail due to timeout
      setTimeout(resolve, 6000)
    }),
  timeout: 5000,
})

doCheck()
```

repository: bufferapp/EKG

repo_name: bufferapp/EKG


text:
# Honeycrisp Design System

A gem including base styles and javascript for Code for America products, for use in Rails applications.

View the current version of the styleguide at [https://honeycrisp.herokuapp.com](https://honeycrisp.herokuapp.com).

## Contributing

We are not currently seeking contributions from the public.

If you have any thoughts or questions about the project, get in touch at <a href="mailto:styleguide<EMAIL_ADDRESS>or the `#cfa-design-toolkit` channel in the Code for America Slack.

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'cfa-styleguide', git: 'https://github.com/codeforamerica/honeycrisp-gem'
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install cfa-styleguide

## Upgrading

The styleguide gem is pre-1.0.0 release, and should be considered as being in beta.

We do our best to keep things stable between minor version releases;
however, decisions about deprecation and breaking changes are made given our knowledge about
the usage of the gem by active projects maintained and developed by Code for America staff.

**When upgrading the gem between patch versions** (e.g. 0.7.1 to 0.7.2), expect no breakage.

**When upgrading the gem between minor versions** (e.g. 0.7.1 to 0.8.0), be sure to review the [changelog](./CHANGELOG.md) and [migration guide](./MIGRATING.md).

If you encounter any breaking changes that we have not documented, please let us know by opening an issue!

## Usage

1. Add `@import 'cfa_styleguide_main';` to application.scss.

1. Add `//= require cfa_styleguide_main` to application.js.

1. Add `mount Cfa::Styleguide::Engine => "/cfa"` to routes.rb.

1. Visit any of the following routes to view the styleguides:

    ```
    `<your hostname>/cfa/styleguide`
    `<your hostname>/cfa/styleguide/cbo-dashboard`
    `<your hostname>/cfa/styleguide/cbo-analytics`
    `<your hostname>/cfa/styleguide/current`
    `<your hostname>/cfa/styleguide/custom-docs`
    ```

1. (Optional) To override the styleguide's variables (e.g. use `#000000` for `$color-background` rather than as defined in the gem), require your own file that redefines the variables in your application.scss like so:

    ```scss
    @import 'my_variable_file'
    @import 'cfa_styleguide_main'

    ```

1. (Optional) To use variables provided by the style guide gem remove `require_tree` directives from your `application.scss` and use use `@import` statements instead ([from stack overflow](https://stackoverflow.com/questions/6269420/sass-global-variables-not-being-passed-to-partials/9055230#9055230))

    ```scss
    # do not use
    *= require_tree .
    ```

    ```scss
    # use instead
    @import 'things_to_import'
    ```

## Development

After checking out the repo, run `bin/setup` to install dependencies. You must install Chromedriver to run tests; on MacOS with Homebrew, run `brew bundle install`

Run `bin/rails s` to start a webserver with a test app that has the engine mounted, then visit `http://localhost:3000`.

### Overriding this gem locally in another project

If the gem is being used in another project's Gemfile, the source can be locally overridden within the other project's Gemfile in two ways:

1. Change the bundler configuration to use the local gem repository

    In the terminal, run `bundle config local.cfa-styleguide /path/to/honeycrisp-gem`

    To install this gem onto your local machine, run `bundle exec rake install`.

    When finished with development, remove this configuration by running `bundle config --delete local.cfa-styleguide` and `bundle install`

1. Change your Gemfile to point to the local gem repository

    Alternatively, you can change host project's `Gemfile` to point to a local copy of this repository. For example, changing:

    ```
    gem 'cfa-styleguide', '~> 0.7', github: 'codeforamerica/honeycrisp-gem'
    ```
    to
    ```
    gem 'cfa-styleguide', '~> 0.7', path: '../honeycrisp-gem'
    ```

    where `../honeycrisp-gem` is the path (relative or absolute) to this repo on the local filesystem.

    After updating the `Gemfile` with these changes, you will need to run `bundle install`.

    When finish, just revert the Gemfile to the original version and `bundle install` again.

### Running tests

A small test suite is available—please add to it!

To run, run `rake` or `rspec spec`.

### Releasing new gem versions

To release a new version, on `master` branch:
* Update the version number in `version.rb` using [semantic versioning](https://semver.org/)
* `bundle install` to update the Gemfile.lock
* Generate an addition to the [changelog](./CHANGELOG.md) using `bundle exec rake changelog`. (Note: you will need to provide a [Github token with public repo access](https://github.com/github-changelog-generator/github-changelog-generator#github-token)).
* If updating the minor version, update the [migration guide](./MIGRATING.md) with any breaking changes and suggestions for what to do about them. If no breaking changes, just add 'no breaking changes'.
* Review, edit as necessary, and commit including the version update.
* Run `gem_push=false bundle exec rake release`, which will create a git tag for the version, and push git commits and tags to Github. In the future, this will also push the `.gem` file to [rubygems.org](https://rubygems.org).

## License

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

## Code of Conduct

Everyone interacting in this project’s codebase, issue trackers, chat rooms and mailing lists is expected to follow the Code for America [code of conduct](https://brigade.codeforamerica.org/about/code-of-conduct).

gha_language: HTML


text:
# Zoolander

A ridiculously good looking ruby gem that adds a view helper to Rails and dishes out Zoolander quotes

## Installation

Add this line to your application's Gemfile:

    gem 'zoolander'

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install zoolander

## Usage

To add some random Zoolander quotes to your view just drop in..

```ruby
<%= zoolander_quote %>
```

## Contributing

1. Fork it
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create new Pull Request

repository: smillea/zoolander

repo_name: smillea/zoolander


text:
### Bar Info

> Request

```
curl -X GET https://bitmax.io/api/pro/v1/barhist/info
```

> Sample response

```json
{
    "code": 0,
    "data": [
        {
            "name": "1",
            "intervalInMillis": 60000
        },
        {
            "name": "5",
            "intervalInMillis": 300000
        },
        {
            "name": "15",
            "intervalInMillis": 900000
        },
        {
            "name": "30",
            "intervalInMillis": 1800000
        },
        {
            "name": "60",
            "intervalInMillis": 3600000
        },
        {
            "name": "120",
            "intervalInMillis": 7200000
        },
        {
            "name": "240",
            "intervalInMillis": 14400000
        },
        {
            "name": "360",
            "intervalInMillis": 21600000
        },
        {
            "name": "720",
            "intervalInMillis": 43200000
        },
        {
            "name": "1d",
            "intervalInMillis": 86400000
        },
        {
            "name": "1w",
            "intervalInMillis": 604800000
        },
        {
            "name": "1m",
            "intervalInMillis":<PHONE_NUMBER>
        }
    ]
}
```

**HTTP Request**

`GET /api/pro/v1/barhist/info`

This API returns a list of all bar intervals supported by the server.

#### Request Parameters

This API endpoint does not take any parameters.

#### Resposne

 Name               | Type      | Description
------------------- | --------- | ---------------------------------------------------
 `name`             | `String`  | name of the interval
 `intervalInMillis` | `Long`    | length of the interval

Plesae note that the one-month bar (`1m`) always resets at the month start. The `intervalInMillis` value for the one-month `bar` is only indicative.

The value in the `name` field should be your input to the [Historical Bar Data](#historical-bar-data) API.

### Historical Bar Data

> Request

```
curl -X GET https://bitmax.io/api/pro/v1/barhist?symbol=BTMX/USDT&interval=1
```

> Sample response

```json
{
    "code": 0,
    "data": [
        {
            "data": {
                "c": "0.05019",
                "h": "0.05019",
                "i": "1",
                "l": "0.05019",
                "o": "0.05019",
                "ts":<PHONE_NUMBER>000,
                "v": "1612"},
           "m": "bar",
           "s": "BTMX/USDT"},
        {
            "data": {
                "c": "0.05019",
                "h": "0.05027",
                "i": "1",
                "l": "0.05017",
                "o": "0.05017",
                "ts":<PHONE_NUMBER>000,
                "v": "57242"
                },
           "m": "bar",
           "s": "BTMX/USDT"},
    ]
}
```

#### HTTP Request

`GET /api/pro/v1/barhist`

This API returns a list of **bar**s, with each contains the open/close/high/low prices of a symbol for a specific time range.

#### Request Parameters

 Name       | Type     | Required | Description
----------- | -------- | -------- | -------------------------------------------------------------------------------------------
 `symbol`   | `String` | Yes      | e.g. `"BTMX/USDT"`
 `interval` | `String` | Yes      | a string representing the interval type.
 `to`       | `Long`   | No       | UTC timestamp in milliseconds. If not provided, this field will be set to the current time.
 `from`     | `Long`   | No       | UTC timestamp in milliseconds.
 `n`        | `Int`    | No       | default 10, number of bars to be returned, this number will be capped at 500

The requested time range is determined by three parameters - `to`, `from`, and `n` - according to rules below:

* `from`/`to` each specifies the start timestamp of the first/last bar.
* `to` is always honored. If not provided, this field will be set to the current system time.
* For `from` and `to`:
  * if only `from` is provided, then the request range is determined by `[from, to]`, inclusive. However, if the range is too wide,
    the server will increase `from` so the number of bars in the response won't exceed 500.
  * if only `n` is provided, then the server will return the most recent `n` data bars to time `to`. However, if `n` is greater than 500,
    only 500 bars will be returned.
  * if both `from` and `n` are specified, the server will pick one that returns fewer bars.

#### Response

Name     | Type   |   value  | Description
---------| -------| ---------| -------------------------------
`m`      | String |`bar`     | message type
`s`      | String |          | symbol
`data:ts`| Long   |          | bar start time in milliseconds
`i`      | String |          | interval
`o`      | String |          | open price
`c`      | String |          | close price
`h`      | String |          | high price
`l`      | String |          | low price
`v`      | String |          | volume in quote asset

#### Code Sample

Please refer python code to [get bar history]{https://github.com/bitmax-exchange/bitmax-pro-api-demo/blob/master/python/query_pub_barhist.py}

repository: bitmax-exchange/bitmax-pro-api

repo_name: bitmax-exchange/bitmax-pro-api


text:
# TypeScript-Handbook (4.1)

The PDF is generated by gitbook. The document is based on [Typescript handlebook](https://github.com/microsoft/TypeScript-Website.git)

For a more formal description of the language, see the [latest TypeScript Language Specification](https://github.com/microsoft/TypeScript/tree/master/doc).

**Note**
it seems that gitbook does not like "docs" folder

repository: zyzbroker/typescript-handbook-pdf

gha_language: Shell

repo_name: zyzbroker/typescript-handbook-pdf


text:
---
title: (Not a) Blog Philosophy
date: 2023-01-15
---

Above all, I don't want to be doing this.

OK, not really. But what I actually am is indecisive (in all things!), and I have competing urges, like:

- Wanting to share the few bits of actual knowledge and experience that, like a [salt-craving mountain goat](https://www.youtube.com/watch?v=f0jMzdbEui0), I've licked off the world
- Genuine deference to people that are smarter and more well-spoken than me

and:

- An allergy to the self-branding of unimpressive technocrats like myself as raconteurs with "hot takes"
- Dear lord, [someone is wrong on the internet](https://xkcd.com/386/)

and:

- I really, _really_ don't want to manage web publishing myself
- Being filled with rage by the tools that are supposed to make this easy

This site is the latest in a long tradition of these priorities flip-flopping and turning into something new.
I don't intend to say much, because I don't have much to say.

I owe a debt of gratitude to [Kyle](https://kylehugh.es) for stealing much of his approach [after a chance conversation on Mastodon](https://mastodon.social/@kyle@mister.computer/109599250472700900).
I like the idea of having a space on the internet whose goal is to **conciously** remove expectations and barriers of self-confidence in order to be more authentic, even mindful.
We'll see if it sticks.

## The Twitter Era

Important stuff happened to me on Twitter. I found myself. I landed a job. I came out. I found the deepest, truest love I've ever had. So it's not like I can forget it. I can't defend it, either.

I was an early adopter, but I was a teenager at the time so it actually became horribly embedded into my psyche for over a decade. A number of people are recognizing the negative impact this has had on them (circa 2023). But I was there already. It killed my mood all the time, and made me worse at communicating thoughtfully. There's dozens more reasons — many on a global scale — but those should be enough for wanting something out of your life.

## Finding a Home

If you're someone with a little technical ability, it's _en vogue_ to hyperobsess over your blog as one of a million eternally-unfinished side projects.
(I'm not bitter.)
I chafe at this for a couple of reasons, the biggest one being the way it leads me down an infinite road of bikeshedding.

I just want to have something _nice_, to free myself up to do the things I actually like to do, that matches my values, and that I can throw money at to solve the hard problems.
In practice, ticking all those boxes is an exercise in frustration.

- The popular website-in-a-box-tools are largely expressive enough, but their pricing economies suck. I am lucky enough to afford it, but throwing that money in the toilet month after month creates an unhealthy association between guilt and writing/sharing/self-promotion.
- I'm aware and excited of the growing tooling on the fediverse, I simply don't want to be a sysadmin. If I can sign in to a thing and update Debian packages, I _will_ do it compulsively.
 Like deciding to take middling native apps and make them worse hybrid apps as a way to "get back" at app stores. I don't actually care that much about the perceived evil of walled gardens, and it simply doesn't make sense to pay into a walled garden I don't like the smell of.

For now, my home is spread between here (for more permanent things) and [Mastodon](https://mastodon.social/@zw) (for more ephemeral things).

branch_name: refs/heads/main


text:
# Socialite

### Because if you're selling your soul, you may as well do it asynchronously.

Socialite provides a very easy way to implement and activate a plethora of social sharing buttons — any time you wish. On document load, on article hover, on any event!

[For a demo visit: **socialitejs.com**](http://www.socialitejs.com/)

Author: David Bushell [http://dbushell.com](http://dbushell.com/) [@dbushell](http://twitter.com/dbushell/)

Copyright © 2012

## Features and Benefits

* No dependencies to use.

* Loads external resources only when needed.
* Less than 2kb when minified and compressed.
* More accessible and styleable defaults/fallbacks.
* Support for Twitter, Google+, Facebook and LinkedIn.
* Extensible with other social networks.
* Mimics native implementation when activated.
* Supported in all browsers (providing the buttons are).

## Setup

Create an element with the class `socialite` and a class like `twitter` to specify the social network. Best practice is to provide an accessible fallback URL like the example below. You can style it however you like! See [http://socialitejs.com](http://socialitejs.com) for demos.

		Share on Twitter

Use `data-*` attributes to configure your button. These configurations directly correlate to the individual network implementations, so while Twitter uses `data-url`, Facebook uses `data-href`. Not ideal but I'd rather keep this script very small!

Supported network classes are currently: `twitter`, `googleplus`, `facebook` and `linkedin`. For other [Twitter buttons](https://twitter.com/about/resources/) add an extra class of either `follow`, `hashtag` or `mention`. For [Embedded Tweets](https://dev.twitter.com/docs/embedded-tweets) copy the `<blockquote>` code provided by Twitter and replace the class attribute with `socialite tweet`.

For all individual button configurations visit [Twitter](https://twitter.com/about/resources/buttons/), [Google+](https://developers.google.com/+/plugins/+1button/), [Facebook](http://developers.facebook.com/docs/reference/plugins/like/) and [LinkedIn](http://developer.linkedin.com/plugins/share-button/). **Important:** don't include the scripts provided by these networks, Socialite does that for you!

Include **socialite.js** right at the end of your document (before `</body>`) and activate with the options below:

## Functions

### Load

	Socialite.load();

`load` will search the document for elements with the class `socialite` and magically transform them into sharing buttons (based on a network class and data-* attributes).

Always wait for at least the `DOMContentLoaded` event — `$(document).ready(function() { });` with jQuery.

	Socialite.load(context);

Be kind! Provide an element to search within using `context` rather than the whole document.

### Activate

	Socialite.activate(element, 'network');

`activate` replaces a single element (or an array of) with the specific social network button.

### Extend

	Socialite.extend('network', function);

With `extend` you can add more social networks! The `function` is called by `Socialite.load` and `Socialite.activate` to replace the default element with the shiny sharing button.

## Contribute

Send me feedback and testing issues!

repository: kristerkari/Socialite

repo_name: kristerkari/Socialite


text:
# CDCS

`CDCS.jl` is an interface to the **[CDCS](https://github.com/oxfordcontrol/CDCS)**
solver. It exports the `cdcs` function that is a thin wrapper on top of the
`cdcs` MATLAB function and use it to define the `CDCS.Optimizer` object that
implements the solver-independent
[MathOptInterface](https://github.com/JuliaOpt/MathOptInterface.jl) API.

To use it with [JuMP](https://github.com/JuliaOpt/JuMP.jl), simply do
```julia
using JuMP
using CDCS
model = Model(with_optimizer(CDCS.Optimizer))
```
To suppress output, do
```julia
model = Model(with_optimizer(CDCS.Optimizer, verbose=0))
```

## Installation

You can install `CDCS.jl` through the
[Julia package manager](https://docs.julialang.org/en/v1/stdlib/Pkg/index.html):
```julia
] add https://github.com/blegat/CDCS.jl.git
```
but you first need to make sure that you satisfy the requirements of the
[MATLAB.jl](https://github.com/JuliaInterop/MATLAB.jl) Julia package and that
the CDCS software is installed in your
[MATLAB™](http://www.mathworks.com/products/matlab/) installation.


text:
# Arduino101-bluetooth-HID-library
A library turn Curie Core boards(Arduino/Genuino 101) into a Bluetooth Keyboard/Mouse.

一个让Arduino 101变成蓝牙鼠标/键盘的库。

## Project progress

~~Bluetooth Keyboard: 85% (available) unstabitily~~

~~Bluetooth Mouse: 85% (available) unstabitily~~

### Development has been suspended.If you have any questions, please submit issue.
### Thank you!

### 该项目开发已经暂停,如果你有任何问题,请提交issue.
### 谢谢!

repository: vhuag/Curie-bluetooth-HID-library

repo_name: vhuag/Curie-bluetooth-HID-library


text:
# WebRTC Video Conferencing with simple-peer
A simple video conferencing example using simple-peer.
This project allows multiple devices to connect with eachother with audio and video using webrtc.
The package [simple-peer](https://github.com/feross/simple-peer) is used for webrtc.
The implementation of the signaling server is done with [socket.io](https://socket.io/)

## Demo
[Demo on heroku](https://dirvann-webrtc-video.herokuapp.com/)

## Running

run `npm install` and then `npm start` in the main directory.

Then open the browser at `localhost:3012` or `[your network ip/ public dns]:3012`.

## Configuration

Configurations can be found in `app.js` and `public/js/main.js`.

Replace the ssl certificates `ssl/key.pem` and `ssl/cert.pem` with your own.


text:
[Back to main page](../README.md)

## Installation instruction - Linux system

These steps have been tested on a Linux Mint 18, a variant of the Ubuntu flavour of linux systems.

### Installing the Anaconda environment

In order to run the exercices from the course, you will need to setup and install __anaconda for python 3__.

On the [anaconda website](https://www.anaconda.com/distribution/), download the python 3.7 version of anaconda. ake sure you are downloading the version that matches your processor type  (you should download the x86 installer)

In the folder where you downloaded the installation script, run the latter using `bash Anaconda3-2019.10-Linux-x86_64.sh`. Type `enter` to start the process
Click here for image

Scroll through the licence agreement by pressing the return key. At the end, type `yes` to accept the license terms and conditions.
Click here for image

Anaconda provides you with a default path where it will install the relevant software. It is recommended that you change this directory name, like the example shown here. Once you have entered a new path name, type the return key and the installation will proceed.
Click here for image

Once the installation is finished, you will be asked if you ant to initialize the environment. __Type `no` to this step__.
Click here for image

Move to your home folder by typing `cd`. Open a file named `.bashrc`, and add the following line at the bottom of the file:
`alias anaconda3="export PATH=/home/username/some_path_name/bin:$PATH;source /home/username/some_path_name/bin/activate"`

Close your terminal and open a new one. When you type in `anaconda3`, your new anaconda environment should load. You are then ready to work on your notebooks.

### Clone the course repository

* Open a __terminal window__.

* If you don't have git installed on your laptop, install it by following [these instructions](https://gist.github.com/derhuerst/1b15ff4652a867391f03#file-linux-md)

* Clone the Applied ML repository using the command
`git clone https://https://github.com/troelspetersen/AppliedML2021 ./AppML2021_local/`.
 Feel free to choose another name for your folder, or just use "." if you want to use the same name (i.e. "AppliedML2021"), which is default/common.

* You now have a local copy of the repository

__Make sure you run the command__ `anaconda3` before running a notebook.


text:
---
title: "In-depth patching"
layout: single
toc : true
permalink: /going-further/advanced-patching/
sidebar:
   nav: "docs"
---

## Mass-patching

### Dancing with the ~~star~~ asterisk

What if we want a bunch of materials using the exact same property? It looks like very annoying to copy-paste a patch for each element, right?

Here comes the `*`! This little char will tell to runtime that `*` = whatever-you-want-characters.

For example, if you have vegetation with many leaves type (and so with many different materials), using `leave` somewhere in their names, you can patch all of these materials in one shot.

```javascript
{
   "*leave*":{
      "useAlphaFromAlbedoTexture": true
   }
}
```

Note that \_runtime is [**case-sensitive**](https://en.wikipedia.org/wiki/Case_sensitivity) (like BabylonJS)!

So in the example above, `oak-leaves.000`, `leavePoplar01.000` and `chestnutleave` materials will be tweaked, but **not** `oakLeaves`.

  See the Pen
  _r.advancedPatching - 01 by Babylon Runtime (@BabylonRuntime)
  on CodePen.

*see [examples/going-further/advanced-patching/01.html](https://github.com/babylon-runtime/_r.assets/blob/master/examples/going-further/advanced-patching/01.html) using [patch.patch](https://github.com/babylon-runtime/_r.assets/blob/master/examples/going-further/advanced-patching/assets/patch.patch)*

How to patch also materials using `Leave` *or* `leave`? We could use `*eave*` selector, but it's not very convenient to read an retrieve. That's why we will use multiple selectors.

### Multiple selectors

Sending multiple selectors is very easy to do, just write them successively separated with a comma `,`:

```javascript
{
   "*leave*, *Leave*":{
      "useAlphaFromAlbedoTexture": true
   }
}
```

In the example above, `oak-leaves.000`, `leavePoplar01.000`, `chestnutleave` and `oakLeaves` materials will be tweaked.

  See the Pen
  _r.advancedPatching - 02 by Babylon Runtime (@BabylonRuntime)
  on CodePen.

*example with the BJS logo in the cornellBox, see [examples/going-further/advanced-patching/02.html](https://github.com/babylon-runtime/_r.assets/blob/master/examples/going-further/advanced-patching/02.html) using [patch02.patch](https://github.com/babylon-runtime/_r.assets/blob/master/examples/going-further/advanced-patching/assets/patch02.patch)*

### Filters

Using our leaves example, you may be wondering "if somes meshes are named using `leave` too, are they patched also?!".

Answer is yes: actually, if a property doesn't exist on an element, \_runtime will write it as kind-of metadatas (we will [talk about that](../metadatas/) later).

So a mesh will get a new property named `useAlphaFromAlbedoTexture`, but considering our example it is totally useless. Note that adding a new property is not a big deal and should not affect neither performances or engine stability.

How to avoid this? We can use a filter, like `:material`

```javascript
{
   "*leave*:material, *Leave*:material":{
      "useAlphaFromAlbedoTexture": true
   }
}
```

Here only material elements using `leave` or `Leave` in their names will be modified!

See [\_r.select API](../../api/select/) to see all available filters.

  See the Pen
  _r.advancedPatching - 03 by Babylon Runtime (@BabylonRuntime)
  on CodePen.

*example with the BJS logo in the cornellBox, see [examples/going-further/advanced-patching/03.html](https://github.com/babylon-runtime/_r.assets/blob/master/examples/going-further/advanced-patching/03.html) using [patch03.patch](https://github.com/babylon-runtime/_r.assets/blob/master/examples/going-further/advanced-patching/assets/patch03.patch)*

## _r.patch()


text:
---
layout: post
title: How Do You Define Your Best?
author: Manal Ghosain
categories:
tags:
---

![Woman on top of mountain](/images/wanderer.jpg)

Why do we excel in doing some things with ease, and struggle with other things?

If something has to do with numbers, I usually do it with calm trust, and without much doubt or judgement. I just start and keep going. But other things (like writing a book) I struggle with.

Ease comes from knowing that we’re doing the best we can. Struggle is the opposite; we don’t know what our best is, so we keep second guessing ourselves.

## The pain of not knowing what our best is

When we don't know what our best is, we tend to do one, or both, of the following:

**Seeking:** We keep looking for training, tools, and resources that we think will transform us into experts in the chosen area.

This constant seeking keeps us hooked in a cycle of searching for the perfect solution. We try something, give up, pick up another thing, then give up, and so on. It's a waste of time, energy, and money.

Nothing out there will help me, or you, in achieving a desired outcome if we don't work at it long enough to see results.

**Comparing:** When you don't know how well you're doing, you'll look for an outside metric to measure your performance against. If you're writing, you'll look at other writers.

There is nothing wrong with looking at others for inspiration. But when we look at others with the sole purpose of judging our progress, we'll be sorely disappointed.

In most cases, we'll exaggerate others' success, and dismiss our progress as not enough. No two people do the same thing the same exact way. But we're willing to ignore this fundamental difference and judge ourselves for not measuring up.

Seeking and comparing are not helpful. They fuel self-doubt and judgment, which can only increase our resistance and fear—the cause of all struggle and pain.

Let's now look at the things that help us in defining our best effort.

## The two elements of best effort

From the things that I know I do well, and the things that I have doubts about, I found two elements that are essential in determining our best effort.

**1- Confidence**

Confidence is usually a matter of familiarity.

When we're not familiar with an activity, we don't know where to begin, and we keep scrambling for the ideal start and outcome.

Unfamiliarity also leads to unrealistic expectations.

When we don't know what we're dealing with, social and cultural expectations can influence our definition of success.

Add the high expectation to social pressure and the search intensifies for the magical shortcut that will accomplish the goal.

Confidence on the other hand helps us clarify our path. Being able to trust that you have what it takes, and that you can do your best, is key.

It doesn't mean you won't have doubts and challenges. But beneath the pain, there is an element of trust in yourself and life.

**Where does confidence come from?**

The more we do something, the more comfortable (confident) we feel. Start with the smallest part of anything that you _know_ you can do—without a doubt.

For example, if you want to start an exercise program, can you trust that you can put your shoes on and walk for a minute?

If you want to write, can you trust that you can sit for five minutes every day in front of a blank computer screen?

If you want to clear clutter, can you trust that you can throw out one piece of junk mail every time you check the mail?

This is the most crucial element that we can revert back to when in doubt.

We strengthen our confidence with every action we take, no mater how small it may seem.

Trust does not rush. When you feel you're doing something right, you won't try to speed up the process. Which means we need to have:

**Motivation**

If we're wishy washy about what we want to do, we will stop when we feel something is taking too long.

Wanting to do something (motivation) is the fuel that keeps us going.

If you don't want to write, or exercise, or take pictures, or clear clutter, look into why you keep coming back to these things.

Sometimes we want to do something but fear stops us. If this is the case, find your basic confidence level and work with it.

Other times we think we want to do something because it sounds cool. Don't underestimate the power of media and culture in subliminally shaping our desires.

If you want to do something but you don't know why you're doing it, try it anyway. Then see how you feel about it. If after doing something for a while you feel "eh" not that big of a deal, it's time to let it go.

Trying something and letting it go is not a waste of time. It's a way to find out if you want it or not. This clarifies your desires and interests.

There will be a few things that truly tickle your heart. Once you find one, stick to it, start and build your confidence level.

If you want to do your best, determine your basic confidence and start. A few practical thoughts about doing our best below.

## Practicing your best effort

Consider the following as you work on your best.

**Start with routine**. It may feel overwhelming to try and do the best we can with a hefty lifelong desire. I suggest trying it with daily activities to get a sense of what it feels like.

Try doing your best when you eat, brush your teeth, walk, or drive.

We're all familiar with these activities, so we have a basic understanding of how we can do them well.

Once we do something well, we'll feel motivated and confident to do other things well.

**Best effort changes over time.** As we do and learn, our confidence will increase, and we can do more.

There will also be days when you feel unmotivated, tired, or physically ill. Doing the one basic thing may be all you can muster. And that's okay.

**Our best is ours, not someone else's best.** Focus on doing the best you can—your standards, your action, and your results. When you do your best for yourself, you'll be able to do your best for others.

Doing the best we can is a great source of joy and peace. Whenever I feel I'm doing my best, there is a calm and trusting feeling that makes everything worth doing, without regard for anything else.

[Doing your best](/doing-the-best-you-can/) is simple. Just trust that you can do something you truly desire, and continue to do it. Your best is always within you.


text:
---
title: "Calico Enterprise Usecases"
weight: 2
date: 2020-08-13T02:28:35-05:00
draft: true
hidden: true
---

### CALICO ENTERPRISE USE CASES

In this module, we will use Tigera’s [Calico Enterprise](https://www.tigera.io/tigera-products/calico-enterprise) to implement the following 3 Amazon EKS use cases:

### 1) Implement Egress Access Controls

   Establishing service to service connectivity within your Amazon EKS cluster is easy. But how do you enable some of your workloads to securely connect to services like Amazon RDS, ElasticCache, etc. that are external to the cluster.

   With Calico Enterprise, you can author DNS Policies that implement fine-grained access controls between a workload and the external services it needs to connect to.

### 2) Troubleshoot Microservice Connectivity

   Troubleshooting microservice connectivity issues can be incredibly difficult due to the dynamic nature of container orchestration in Amazon EKS. Connectivity issues can be related to network performance, but often are the result of your Network Policies not being defined properly.

   With Calico Enterprise, you can explore a visual representation of all your microservices communicating with each other, and filter by connections that were accepted and denied. You can further drill into an individual denied connection to see which Network Policy evaluated and denied the connection, and then fix the policy to resolve the connectivity issue.

### 3) Implement Enterprise Security Controls

   Many applications have compliance requirements such as workload isolation, ensuring dev cannot talk to prod or implementing network zones (e.g. DMZ can communicate with the public internet but not your backend databases). While you can implement these rules using open-source Project Calico, there are a few limitations:
  - It is possible for other users to inadvertently override or intentionally tamper with your security controls, and very difficult to detect when that happens.
  - Proof that the policies have been enforced now and in the past is not possible

With Calico Enterprise, you can implement Security Controls at a higher precedent policy tier that cannot be overridden by other users. You will also learn how to provide audit reports that demonstrate compliance now and historically, as well as audit (or alert on) changes to policies.

repository: techsolx/eks-workshop

gha_language: CSS

repo_name: techsolx/eks-workshop


text:
# :money_with_wings: Argent

Argent is a simple Javascript library for converting currency amounts to a second currency.

- Provides a simple conversion API for programmatic use
- Automatically manages session storage for user currency selection
- Optionally scan page and automatically convert amounts to target currency
- Listens to `?currency` parameter plus an optional dropdown for target selection
- Uses [Numeral](https://github.com/adamwdraper/Numeral-js) under the hood for configurable formatting of converted amounts

## Installation

### Imported module (recommended)

Use this method if you are transpiling your code with something like Webpack.

```bash
yarn add @arkade/argent
# or npm add @arkade/argent --save
```

```js
import Argent from "@arkade/argent"

const argent = new Argent({ ... });
```

### Standalone build

A standalone web build has been included at `dist/argent.js` and `dist/argent.min.js`. Include this file somewhere in your page (before the closing `</body>` recommended) before instantiating Argent.

Optionally, you could include the file from [unpkg.com](https://unpkg.com).

```html
<script<EMAIL_ADDRESS><script>
  var argent = new Argent({ ... });
</script>
```

## Usage

### Instantiating Argent

Before you can begin converting currencies, you will need an instance of Argent.

```js
const argent = new Argent({
  rates: { USD: 1, AUD: 0.720461, GBP: 1.30749 },
  baseCurrency: "AUD"
});
```

### Converting a single currency amount

To convert formatted amounts between two currencies, use the `convertFormatted` method.

```js
argent.convertFormatted("$300", "AUD", "GBP"); // Returns "$165 GBP"
```

The shortcut `convertFormatted` method internally does the following.

```js
let aud = argent.parse("$300"); // Returns a Numeral instance with value 300
let gbp = argent.convert(aud, "AUD", "GBP"); // Returns a numeral instance with value 165.31
argent.format(gbp, "GBP"); // Returns "$165 GBP"
```

### Converting all currencies on the page

Using the `convertFormattedNodes` method, you can easily parse the entire page for a particular [selector](https://developer.mozilla.org/en-US/docs/Web/API/Document/querySelectorAll) and convert to the target currency.

```js
argent.convertFormattedNodes(".currency", "AUD", "GBP");
```

## Session management

Argent contains an in-built mechanism for remembering which currency the user has selected. This allows you to ommit the `from` and `to` arguments in the usage methods as currencies will always be converted from your `baseCurrency` and to the target currency selected by the user.

Once a currency is selected, it will be remembered using LocalStorage or the compatible equivalent.

### Selecting a target currency

The following methods are available for currency selection:

- Append `?currency=AUD` to the URL
- Call the `argent.setCurrency('AUD')` method (refreshes the page by default)
- Change a bound currency selector input (see below)

### Binding a currency selector input

You will most likely wish to provide a `<select>` input for your users to select a target currency. If you have one, you can bind it using the `registerCurrencySelector` method. Any updates to the input will automatically trigger the `argent.setCurrency()` method and refresh the page.

```js
argent.registerCurrencySelector('select[name="currency"]');
```

### Getting the current target currency

```js
argent.getCurrency();
```

## Options reference

```js
new Argent({
  // Object containing exchange rates (required)
  rates: {
    USD: 1,
    GBP: 1.30749,
    EUR: 1.16364,
    AUD: 0.720461
  },

  // Object containing formatting rules for each currency (optional)
  // A default is provided, formats given here will merge
  formats: {
    AUD: { symbol: "$", code: "AUD" },
    EUR: { symbol: "€", code: "EUR" }
  },

  // Base currency to convert from (required)
  baseCurrency: "AUD",

  // Default currency to convert to (optional, defaults to baseCurrency)
  defaultCurrency: "AUD",

  // Numeral format string for amounts in base currency (optional, includes decimals)
  baseFormat: "0,0.00",

  // Numeral format string for amounts in converted currency (optional, excludes decimals)
  convertedFormat: "0,0"
});
```

## API reference

## Why the name Argent?

Argent means _Money_ in French :fr:

repository: arkade-digital/argent

repo_name: arkade-digital/argent


text:
---
date: 2016-03-09T20:08:11+01:00
title: Writing validations
weight: 30
---

## Scenario Definition

Validations are special actions, designated to validate the state of an infrastructure component.

## HDFS Validations

In the previous section we saw how to execute actions on HDFS without verbosity existing in the respective Java APIs. In this section we will how to write validations for the HDFS Storage.

```scala
validate(description = "Check file status ",hdfsConf){ hdfs =>

      //Fetch the property that needs to be validated
      val fileStatus = hdfs.usingFS(fs => fs.getFileStatus(new Path("/user/hdfs/data.in")))

      //Use the given function as the behavior driven test constructor
      given(fileStatus) { status =>
        assertEquals(10285689L,status.getBlockSize)
      }
    }
```
Every `validate` function, acts as validation task builder, which takes the Storage configuration as a parameter and expects a function that would build a validation rule with the returned Storage instance.
```scala
def validate[S <: Storage](config: Config[S])(fnRuleBuilder : S => ValidationRule[S])
```

**RabbitMQ Validations**
```Scala
//create the RabbitMQ instance that needs to be validated. The host here ${rabbit.host} would be resolved at the runtime.
val rabbit = new RabbitMQConfig("${rabbit.host}")

validate(description = "Check rabbitmq exchanges", rabbitConf) { rabbit =>

      val listofExchanges = rabbit.usingAdmin(admin => admin.getExchanges)

      given(listofExchanges) { exchanges =>
        val exchangNames = exchanges.asScala.map(_.getName)

        assertEquals(true, exchangNames.contains("amq.topic"))
        assertEquals("amq.headers", exchangNames.find(_.contains("headers")).get)

      }
    }
```

The validation rule builder `given` method takes the state of the object that needs to be validated and the state is created at the runtime by the JetProbe. This way the framework frees the developers to write the boilerplate code pertaining to connecting to RabbitMQ and fetching the
required details, instead the developer would just need to extract the required value for validating the state of the component.

## MongoDB Validations

For validating the mongodb components like database, collection and the records, there are some utility methods allowing the developers to quickly write the validation rules
given the state of the component as a POJO/case class(approx).

```scala

// Declare the instance of MongoDB Sink that needs to be validated
 val mongo = new MongoDBConf("mongodb://${mongo.host}/")

 validate(description = "check database stats",mongoConf){ mongo =>

      given(mongo.getDatabaseStats("zoo")){ dbStats =>

        assertEquals(2,dbStats.get("indexes").get.asInt32().getValue)
      }
    }
```

## HTTP validations

A common use case is to validate the HTTP requests for response code and content. Currently the framework supports json based response validation.
First let's define a http request.

```scala
val getPosts = Http("get-comments")
    .get("https://${server.hostname}/comments/post/1")
```
Let's assume that the response is as below.
```json
{
    "_reqId": "5a1b2cea4f066c709e376366",
    "page": 0,
    "commentsCount": 400,
    "comments": [
      {
        "_id" : "2541",
        "content" : "Hi ! How are you ?",
        "author" : "Dan"
      },
      {
        "_id" : "2542",
        "content" : "Rocking now with JetProbe",
        "author" : "Don"
      }
    ]
  }
```
Now for such json response, we can express the validation as below.

```scala
validateGiven("Testing a negative case",getPosts) { res =>

     given[String]("$.data.first_name") { resp =>
       assertEquals("Janet2",resp)

     }
   }
```

## Execution of Pipelines

A typical scenario would consist of collection of pipelines, which would get executed by the Jetprobe runtime library and at the end the results would be available both in the console and the HTML file.

Follow the steps to run the scenario :

* Package the class file into a jar. If you are using sbt to build the project then just use `sbt package` to build the jar.
* Create a yaml configuration file say `config.yml` that would contain the properties that are being defined in the scenario definition.

```yml
//Name of the Scenario
name : data ingestion test
project : user-analytics

tags :
  - https
  - mongo
  - test

# params for the pipelines
params :
  mongo.host.name : xx.xx.xxx.xxx
  reporter.html.outputPath : /path/to/report.html

pipelines :
  - name : Mongo-prep
    className : com.jetprobe.sample.MongoSuite
    description : Mongo db preparation
    exitOnFailure : true
```
and save it at say `/data/path/config.yml`. Use the jar to run the validations as below.

  ```sh
  $ jetprobe --jar /path/to/job.jar --config /data/path/config.yml
  ```

For more examples, head over to the [example project](https://github.com/jetprobe/jetprobe/tree/master/jetprobe-sample/src/main/scala/com/jetprobe/sample)

repository: jetprobe/jetprobe-docs

repo_name: jetprobe/jetprobe-docs


text:
# CRUD_Package

Basically this repository provides
- package of CRUD operations
- check IP in URL package
- Observers
- Accessors & Mutators
- Mailables Using Mailtrap
- Facades Demo
- Collection Demo with DbSeeders
- Snappy PDF
- Eager Loading
- Authorization using Laravel Gate
- Lravel Closure
- Laravel Debugger.

These all functionalities are implemented in mainly check_access branch and at primary level for beginners to understand easily.

gha_language: PHP


text:
# Aws Rsync

Rsync local files to an AWS EC2 instance for a faster development flow.

This tool is useful for working with single EC2 instances.  It takes the instance's id as the main argument and uses it to look up the instance's IP address. It then rsyncs your local project folder to the EC2 instance.

Some convenient things the tool does:.

* Allows you to use a local text editor of your preference and have your changes reflected on the server pretty quickly.
* Watches your files for changes and automatically re-syncs.
* Some useful rsync default options are pre-configured. These can be overridden if desired.
* The rsync exclude option is derived from your `.gitignore` and `.dockerignore` files. These can be overridden if desired.

## Usage

```sh
aws-rsync sync INSTANCE_ID # one time rsync call
aws-rsync sync INSTANCE_ID --watch # auto re-sync
```

For example, say you are in a [demo-rails](https://github.com/tongueroo/demo-rails) folder, and you run the command in the folder.  It will sync that demo-rails folder to the home folder of the EC2 instance.

```sh
$ git clone https://github.com/tongueroo/demo-rails
$ cd demo-rails
$ aws-rsync sync i-123456789
=> rsync --delete --numeric-ids --safe-links -axzSv --exclude='.git' --exclude='tmp' --exclude='log' --exclude='/.bundle' --exclude='/log/*' --exclude='/tmp/*' --exclude='!/log/.keep' --exclude='!/tmp/.keep' --exclude='/node_modules' --exclude='/yarn-error.log' --exclude='.byebug_history' --exclude='config/database.yml' ./ ec2-user@<IP_ADDRESS>:demo-rails
building file list ... done

sent 2742 bytes  received 20 bytes  1841.33 bytes/sec
total size is 38976  speedup is 14.11
Last synced at: 2018-02-02 17:07:00 -0800
```

Let's verify that the files are on the server now:

```
$ ssh<EMAIL_ADDRESS>'ls'
demo-rails
$ ssh<EMAIL_ADDRESS>'ls demo-rails | head -3'
app
bin
config
$
```

### Watch folder and automatically re-sync

Running the command with the `--watch` flag will sync once and then monitor the local directory for any file changes. When changes are detected, it'll automatically call sync again.

This allows you to use any local editor you prefer and have your changes reflect on the server pretty quickly.

### More Examples

```sh
aws-rsync sync i-123456789
aws-rsync sync i-123456789 --watch
aws-rsync sync i-123456789 --private-ip
aws-rsync sync i-123456789 --private-ip --watch
aws-rsync sync i-123456789 --user ec2-user
aws-rsync sync i-123456789 --noop
aws-rsync sync -h # more help
```

## Overriding the rsync command

You can override the rsync command with 2 environment variables:

* AWS\_RSYNC_OPTIONS: Override the rsync main options used.
* AWS\_RSYNC_EXCLUDE: Override the rsync exclude options used.

The pre-configured rsync options are listed here for convenience. For the most up to date pre-configured options, reference the source code here [sync.rb](lib/aws_rsync/sync.rb).

```sh
  --numeric-ids               don't map uid/gid values by user/group name
  --safe-links                ignore symlinks that point outside the tree
  -a, --archive               recursion and preserve almost everything (-rlptgoD)
  -x, --one-file-system       don't cross filesystem boundaries
  -z, --compress              compress file data during the transfer
  -S, --sparse                handle sparse files efficiently
  -v, --verbose               verbose
      --delete                delete extraneous files from destination dirs
```

## Installation

```sh
$ gem install aws-rsync
```

## Contributing

1. Fork it
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am "Add some feature"`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create new Pull Request

repository: tongueroo/aws-rsync

repo_name: tongueroo/aws-rsync


text:
Translator: tom carter

Reviewer: Bedirhan Cinar
Most people have heard the word "gerrymandering" once or twice,
probably during a presidential election.
What exactly is gerrymandering?
Essentially, it's the process of giving one political party an advantage over another political party
by redrawing district lines.
It's like Democrats trying to gain an advantage over Republicans,
or Republicans trying to gain an advantage over Democrats.
You see, each party wants to gain as many districts as possible
so they can do things like control the state budget,
or set themselves up to win even more districts in the future.
So to understand how this process began, and how it continues today,
we must go back to 1812 in Massachusetts.
Elbridge Gerry, the governor of Massachusetts, supported and signed a bill to allow redistricting.
That is, redrawing the boundaries that separate districts.
The catch? The new lines would favor Gerry's own political party,
the Democratic-Republican party, which no longer exists.
You see, Gerry wanted his party to win as many state Senate seats as possible.
The more members of your party who vote, the more likely you are to win an election.
The new lines were drawn to include loads of areas that would help Governor Gerry in the future.
They were so strange looking that someone said the new districts looked like a salamander.
The Boston Gazette added Gerry's name to the word salamander,
and voilà! Gerrymandering,
the process of dividing up and redrawing districts to give your political party an advantage.
So how exactly does someone go about protecting their own political party,
and actually gerrymandering a district?
There are two successful practices.
Packing a district,
and cracking a district.
Packing is the process of drawing district lines and packing in your opponents like cattle,
into as few districts as possible.
If more districts equals more votes, the fewer the districts there are,
the fewer votes the opposition party will get.
Packing, then, decreases the opponent's voter strength and influence.

Cracking is the opposite:
taking one district and cracking it into several pieces.
This is usually done in districts where your opponent has many supporters.
Cracking spreads these supporters out among many districts,
denying your opponent a lot of votes.
When you have a large number of people who would generally vote for one type of party,
those folks are known as a voting bloc.
Cracking is a way to break that all up.
So when would a party choose to pack their opponent's districts rather than crack them?
Well, that really depends on what the party needs.
To dilute your opponent's voters, you could pack them into one district
and leave the surrounding districts filled with voters of your own party.
Or, if you and your party are in power when it's time to redraw district lines,
you could redraw districts and crack up a powerful district
and spread your opponent's voters out across several neighboring districts.
So, Governor Gerry in 1812 wanted to gain an advantage for his party,
and redrew district lines in his state in such a crazy way we have a whole new word
and way of thinking about how political parties can gain advantages over their opponents.

So the next time an election comes around,
and politicians ask people to vote,
be sure to look up the shape of your district and the districts that surround it.
How wide does your district stretch across your state?
Are all of the districts in your state relatively the same shape?
How many other districts does your district touch?
But always be sure to ask yourself,
does my district look like a salamander?

repository: prewittdavon/TEDVis

repo_name: prewittdavon/TEDVis


text:
## Description

<!-- Please add a short summary about what the pull request is going to bring on the table -->

## Changes

<!-- Please add list of more detailed changes. These changes should be reflected also in the commit messages -->

*
*
*

## Reference

<!-- Please add the corresponding issue number which this pull request is about to fix -->
Fixes #

<!--
Please add an entry to CHANGELOG.adoc file, too, as part of your Pull Request.

In the following cases, add a short description of PR to the unreleased section in CHANGELOG.adoc:

- 🎁 New feature
- 🐛 Bug fix
- ✨ Feature Update
- 🐣 Refactoring
- 🗑 Remove feature or internal logic

See other entries in CHANGELOG.adoc as an example for how to add the entry, including a reference to the corresponding issue/PR

PLEASE DON'T ADD THAT LINE HERE IN THE PULL-REQUEST DESCRIPTION BUT DIRECTLY IN CHANGELOG.ADOC AND ADD CHANGELOG.ADOC AS PART OF YOUR PULL-REQUEST.
-->

<!--
To automatically lint go code in this pull request uncomment the line below. You get feedback as comments on your pull request then -->

<!--
/lint
-->

repository: smsufyian/client

repo_name: smsufyian/client


text:
## Starting Dog

To start Dog, first check if a Java 1.6 or superior JRE ([www.java.com](http://www.java.com "Java")) is installed on your computer.

Then:

* on Microsoft Windows:
	double click on start_dog.bat
* on Unix-like systems:
	execute on a terminal window the bash script ./start\_dog.sh

## Testing Dog

When Dog is up and running you see an *osgi>* prompt on the terminal window from which the Dog script has been launched.
This prompt belongs to the OSGi console and will display information about Dog, allowing, at the same time, to type framework and platform commands.

Type *ss* at the OSGi prompt for retrieving the status of all the Dog bundles when the gateway is working. All the bundles should be ACTIVE.

repository: dog-gateway/standalone-version

repo_name: dog-gateway/standalone-version


text:
# `::fork`

cf. [FORK(2) Linux Programmer's Manual](http://man7.org/linux/man-pages/man2/fork.2.html)

```
#include <sys/types.h>
#include <unistd.h>

pid_t fork(void);
```

`fork()` creates new process by duplicating the calling process.
New process is referred to as the *child* process. The calling process is referred to as the *parent* process.

Child process and parent process run in separate memory spaces.
- At time of `fork()` both memory spaces have same content.
  * Memory writes, file mappings (`mmap`), and unmappings (`munmap`) performed by 1 of processes don't affect the other.

repository: ernestyalumni/HrdwCCppCUDA

repo_name: ernestyalumni/HrdwCCppCUDA


text:
## Lifull Survey

## Table of Contents
- [Table of Contents](#table-of-contents)
- [Overview](#overview)
- [Features](#features)
- [Requirements](#requirements)
- [Getting Started](#getting-started)
- [License](#license)

## Overview
Lifull Survey is a library for introducting surveys in the application.

## Features
・Multiple Questionnaire Pages

・Any Answer Type

  ・Single Answer

　・Multiple Answers

　・OpenEnded

## Requirements
* Android API level 21 to use

## Getting Started
```gradle:{root}/build.gradle
allprojects {
    repositories {
        google()
        jcenter()

        maven {
            url 'https://lifull-dev.github.io/lifull-survey/repository/'
        }
    }
}
```

```gradle:{project}/build.gradle
dependencies {
    implementation 'com.lifull.android:item-survey:1.0.0'
}
```

## License
Copyright 2020 Lifull., co Ltd.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

repository: lifull-dev/lifull-surveys

repo_name: lifull-dev/lifull-surveys


text:
---
name: Maquis Takeover Seska
rarity: 5
series: voy
memory_alpha:
bigbook_tier: 3
events: 15
in_portal: true
date: 12/11/2020
obtained: Event
mega: false
published: true
---

First things first: For CMD/ENG voyagers, there's Braxton and then there's everyone else. Seska is in no danger of dethroning the Voyage King, but she does bring a lot to the table. Hailing from a delightfully fun episode, she debuts with good (but not game-breaking) voyage power in a relatively uncommon skill order, a top ten CMD base, and a collection.

As for event futures, dismal variant event chances meet a trait set that is truly outstanding. She has three racial traits including hologram which has already seen a mega and some one-offs, as well as juicy untapped traits like crafty, villain, and undercover operative. While you're waiting for her traits to pop for events, they can yield an antimatter bonus on common voyage seats. +1 Cardassian never hurt anyone (collection expansion when?), and for a Cardassian mega she'd be up there with Saboteur Garak as one of the best two options in the game.

Seska won't help in the gauntlet or with ship battles, so folks who are already stocked with the best CMD/ENG voyagers in the game may not see her move the needle outside of events. For everyone else, she brings solid base and voyage power combined with a plus trait set that should keep her contributing for a long time.

repository: ussjohnjay/sttdatacore-website

repo_name: ussjohnjay/sttdatacore-website


text:
+++
title = "Recipes"
chapter = true
weight = -10
prev = "/usage/top"
next = "/recipes/batch"
+++

# Recipes

The majority of workloads that are run on cloud infrastructure can be broken down into three major categories: **batch**, **long running**, or **repeated**. We provide examples of running each of these workloads below:

#### [Batch](/mesos-cli/recipes/batch)

Run on-demand, are usually synchronous, and produce some fixed result like a transformed file.

#### Long Running (coming soon)

Long running workloads are often server processes which need to be restarted if they fail.

#### Repeated (coming soon)

Repeated workloads run at some fixed interval and are scheduled with a system like cron.

repository: mxnavi/mesos-cli

repo_name: mxnavi/mesos-cli


text:
argsimple
=========

Argsimple is Python package for making clean and useful command line interfaces with as little configuration as humanly possible.

Some of the key features of the packages are:
- Automatic generation of a help page
- Easy declaration of mutually exclusive arguments
- Lazy loading of arguments during runtime

# How to install

Argsimple requires Python version 3.6 or higher.

Install using [pip](https://pip.pypa.io/en/stable/quickstart):

```shell
pip install argsimple
```

# How to use

Here's a simple example:

```python
import argsimple

argsimple.add("-w", "--word", help="a word to print")
argsimple.add("-c", "--count", type=int, help="print this many times")

print(argsimple.word * argsimple.count)
```

```shell
$ python my_scipt.py -w spam -c 3
spamspamspam
```


text:
# Decaf-Compiler

## Description

Compiler for [Decaf](https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-035-computer-language-engineering-spring-2010/projects/MIT6_035S10_decaf.pdf) Programming Language. Developed as a course project for Compilers course.
Decaf is a strongly-typed, object-oriented language with support for inheritance and encapsulation. By design, it has many similarities with C/C++/Java, so you should find it fairly easy
to pick up. But it is not an exact match to any of those languages. The feature set has been trimmed down and simplified to keep the programming projects manageable

## Approach

- Firstly, we perform lexical analysis on the given code
and break down the input code into tokens.
- Next we do semantic analysis and transform this set of tokens into an
AST (Abstract Syntax tree) using _Vistor design pattern_ approach
- Once AST is prepared, we generate the _Intermediate Representation_

## Frameworks used
- [Flex](ftp://ftp.gnu.org/old-gnu/Manuals/flex-2.5.4/html_mono/flex.html) for lexical analysis
- [YACC](http://dinosaur.compilertools.net/yacc/) for semantic analysis
- [LLVM](http://llvm.org/) for generating the IR

## Reference
- Code Documentation can be found [here](/html/index.html)
- Instructions for running the code can be found [here](https://github.com/harry-7/Decaf-Compiler/blob/master/README.md)

repository: hkveeranki/Decaf-Compiler

repo_name: hkveeranki/Decaf-Compiler


text:
# Proximity Beacon API Scripts

This is not an official Google product

## Introduction

These scripts provide a wrapper around the REST service for the [Proximity Beacon API](https://developers.google.com/beacons/proximity/guides)
 (PBAPI), Google's service for registering and monitoring beacons and related data. They are not meant to be a complete
 solution for interacting with the service, rather as a helper for some of the common functions and a starting point for
 building something greater.

Other tools for the PBAPI that have similar function include:
- The Beacon Tools apps ([Android](https://play.google.com/store/apps/details?id=com.google.android.apps.location.beacon.beacontools), [iOS](https://itunes.apple.com/us/app/beacon-tools/id1094371356))
- The [beacon management dashboard](https://developers.google.com/beacons/dashboard/)

## Getting Started

This project is based around the [Python Google API client](https://developers.google.com/api-client-library/python/)
for which you can find installation instructions [here](https://developers.google.com/api-client-library/python/start/installation).

For all other dependencies, just run setup.py:

  python setup.py install

### Credentials and Authentication

The PBAPI is an authenticated service, and requires a Google developer project with an associated service client. At a
 high level, you can generate the required credentials via the following steps:

1. Create (or select) a project in the [developer console](https://console.developers.google.com).
2. Enable the Google Proximity Beacon API
3. From credentials, create a new 'Service account key'
4. Select the JSON key type
5. Save the key in a safe place, but preferably on the same filesystem as these scripts

This key should be of the following format (note that this is a _service account_ key, distinctly different from an
OAuth client ID):

    {
      "private_key_id": "123456789abcdefghijklmnop",
      "private_key": "<REDACTED_PRIVATE_KEY>\n",
      "client_email"<EMAIL_ADDRESS>      "client_id": "1234567890-exampleserviceaccount1234567890.apps.googleusercontent.com",
      "type": "service_account"
    }

**_NEVER CHECK THIS FILE INTO VERSION CONTROL! ADD TO .gitignore IMMEDIATELY!_**

The client also supports these credentials in p12 format, as well as temporary OAuth access tokens.

## Running

Once installed, the primary entry point is via the `pb-cli` command. Its arguments follow this pattern:

    pb-cli {global opts} [command] {command-specific opts}

`{global opts}` are almost exclusively around authentication. See `pb-cli --help` for more details, `pb-cli
--list-commands` for a list of which PBAPI methods are supported, or `pb-cli [command] --help` for usage details on
a specific method.

### List names of all beacons owned by a service account

    $ pb-cli --service-account-creds ./creds.json list-beacons --names-only
    beacons/3!12345678901234567890123456789012
    beacons/3!abcdefabcdefabcdefabcdefabcdefab
    beacons/3!abcdef1234567890abcdef1234567890
    *snip*

### List names of all beacons owned by a different project

This scenario requires that the service account client email has been given an appropriate PBAPI IAM role in
`my-beacon-project`. A more common scenario is that your developer account (e.g<EMAIL_ADDRESS>has been granted this
IAM role (e.g., by joining a Google Group). In that case, substitute `--service-account-creds <creds file>` with
`--access-token <access token>`, using an OAuth token tied to you developer account and a projec that has the PBAPI
enabled.

    $ pb-cli --service-account-creds ./creds.json list-beacons --names-only --project-id my-beacon-project
    beacons/3!12345678901234567890123456789012
    beacons/3!abcdefabcdefabcdefabcdefabcdefab
    beacons/3!abcdef1234567890abcdef1234567890
    *snip*

### Filter beacon list by query

The PB CLI also supports filtering beacons by the given values. Status (`--status`) and property key/values
(`--property`) are first-class options, but you can also give arbitrary query strings as specified by the
[beacons.list](https://developers.google.com/beacons/proximity/reference/rest/v1beta1/beacons/list) API documentation.

For example, the following will return only the active beacons:

  $ pb-cli --service-account-creds ./creds.json list-beacons --status active

And the following command will return the beacons that have places set in the Seattle area:

  $ pb-cli --service-account-creds ./creds.json list-beacons --query 'city:"Seattle"'

### Register a beacon

    $ pb-cli --service-account-creds ./creds.json register-beacon --beacon-json '{"advertisedId":{"type":"EDDYSTONE","id":"<id>"},"status":"ACTIVE"}'
    *snip*

Note that `<id>` is expected to be already encoded [as expected by the API](https://developers.google.com/beacons/proximity/reference/rest/v1beta1/AdvertisedId).
 If you have a 32-byte UUID-like string (e.g., 'abcdef1234567890abcdef1234567890'), you can generate the encoded ID
 with the following one-liner:

    $ id='abcdef1234567890abcdef1234567890'; python -c "import binascii; import base64; print base64.b64encode(binascii.unhexlify('$id'))"

If the beacon is an iBeacon `register-beacon` will decode the ID to separate out the Proximity UUID and the
major/minor IDs. For each of these, it will add properties to the beacon: `ibeacon_uuid`, `ibeacon_major`, and
`ibeacon_minor`. To turn off this feature, specify the `--no-ibeacon-props` option.

### Create an attachment

Since attachments in the PBAPI have only two user-settable fields, the `create-attachment` method accepts these
straight on the command line. A couple of important notes for `create-attachment`:

* Specifying `--project-id <ID>` dictates the owning project of the **attachment**, not of the beacon.
* If you need to create an attachment on a beacon you don't own, ensure that your authenticated user has been grated
an IAM role for attachment editing in the owning project. _You may need to contact the project's owner for this._
* Beacon names include an exclamation point, which is a special shell-expansion character. Be sure to properly quote
or escape.

```
$ pb-cli --service-account-creds ./creds.json create-attachment \
    --beacon-name 'beacons/3!12345678901234567890123456789012' \
    --namespaced-type my-beacon-project/json \
    --data '{"key":"value"}'
```

### Look up and set place IDs for beacons

The pbapi module includes a helper function for looking up a place ID and associating it with a beacon. If you
already have a beacon name to place ID mapping, this function can also handle the updates for you. In order to do the
 lookup though, you must have a valid [Google Maps API key](https://developers.google.com/maps/web/).

The `set-places` method takes in the path to a CSV file that has a `beacon_name` field and a location. The location
field can be one of `place_id`, `latitude,longitude`, or `address`. All entries in the file must use the same
location type.

For example, if we knew the lat/long for all of our beacons, we might have an input CSV that looks like:

    beacon_name,latitude,longitude
    beacons/3!12345678901234567890123456789012,47.6489529,-122.3508952
    beacons/3!abcdefabcdefabcdefabcdefabcdefab,47.6487529,-122.3509592
    beacons/3!abcdef1234567890abcdef1234567890,47.649585,-122.350420

`set-places` will lookup the closest place to these coordinates (in this case, Google Seattle for all three), and
update the beacon with that place ID:

    $ pb-cli --service-account-creds ./creds.json set-places --source-csv ./beacon-places.csv --maps-api-key <API KEY>
    *snip*

Note that in particularly dense locations or in cases where multiple places share the same address (e.g., malls),
this may not return the desired Place ID. It's recommended that you spot check these in the [Beacon Dashboard](https://developers.google.com/beacons/dashboard).

### Bulk Register Beacons

Using `pb-cli`, you can register a set of beacons using a single command. For example:

    $ pb-cli --service-account-creds ./creds.json bulk-register --source-csv ./beacons.csv

The input CSV file must at minimum have an ID field (i.e., the broadcast ID of the beacon), but can contain any
number of fields. The primary [Beacon Resource fields](https://developers.google.com/beacons/proximity/reference/rest/v1beta1/beacons#Beacon)
are expected to be in snake_case and are individually set if available. Any remaining, unknown fields (e.g., custom
fields like `store_name`) are included as keys in the beacon's `properties` map.

For example, suppose `beacons.csv` has the following contents:

    id,latitude,longitude,indoor_level,description,tx_power
<PHONE_NUMBER>1234567890123456789012,47.6489529,-122.3508952,1,Entry way,-40 dBm
    abcdefabcdefabcdefabcdefabcdefab,47.6487529,-122.3509592,2,Second floor cafe,-20 dBm
    abcdef1234567890abcdef1234567890,47.649585,-122.350420,3,Desk,-60 dBm

The first beacon would be created as:

```
{
    'beaconName': 'beacons/3!12345678901234567890123456789012',
    'advertisedId': {
        'id': 'EjRWeJASNFZ4kBI0VniQEg==',
        'type': 'EDDYSTONE'
    },
    'status': 'ACTIVE',
    'expectedStability': 'STABLE',
    'latLng': {
        'latitude': 47.6489529,
        'longitude': -122.3508952
    },
    'indoorLevel': {
        'name': '1'
    },
    'description': 'Entry way',
    'properties': {
        'tx_power': '-40 dBm'
    }
}
```

The `bulk-register` command can also register iBeacons. It will perform the proper encoding of the UUID, Major, and
Minor IDs and set these as additional properties. For example, given the following input CSV:

    type,uuid,major,minor
    IBEACON,12345678-9012-3456-7890-123456789012,111,222

`bulk-register` would create the following beacon:

```
{
    'beaconName': 'beacons/1!12345678901234567890123456789012006f00de'
    'advertisedId': {
        'type': 'IBEACON',
        'id': 'EjRWeJASNFZ4kBI0VniQEgBvAN4='
    },
    'status': 'ACTIVE',
    'expectedStability': 'STABLE',
    'properties': {
        'ibeacon_major': '111',
        'ibeacon_uuid': '12345678901234567890123456789012',
        'ibeacon_minor': '222'
    }
}
```

Finally, `bulk-register` can also make use of the same facilities as the `set-places` command. That is, by supplying
`--set-places` and a Google Maps API key as part of the `bulk-register` command, an address or lat/long will be
parsed out of the input CSV and used to look up a plausible Google Maps Place ID.

See `pb-cli bulk-register --help` for additional information.

License
=======

    Copyright 2016 Google, Inc.

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.

repository: steelburn/beacon-platform

repo_name: steelburn/beacon-platform


text:
---
path: "/posts/lgYG"
title: "NodeHost got a new custom panel."
author: "Anthony Rossbach"
authorUrl: "https://twitter.com/anthonyrossbach"
---

[www.nodehost.ca](http://www.nodehost.ca/)

So before now the system uses vestacp on each node because of it's amazing API and light resource usage. So the panel on NodeHost would allow creation on our panel but make the user go to the vestaCP to work and manage the site.

**But no more.**

I have started building over the last 4-5 days a new panel, that uses the API to build into the main panel everything that is needed. It talks to the node servers VestaCP install via it's API to do all the work but keeps all user interaction on my NodeHost panel making things simple and easy. Check it out and give me feedback if you can.

repository: codebeeio/archive

repo_name: codebeeio/archive


text:
---
layout: default
title: Release 0.9.3
---

JHipster release 0.9.3
==================

*JHipster gives you Yeoman + Maven + Spring + AngularJS all working together in one handy generator.*

What's new
----------

We corrected two JavaScript libraries issues:

* Angular-Translate 2.0.0, which was released today, was marked compatible by Bower but had an API change, see [#125](https://github.com/jhipster/generator-jhipster/issues/125)
* JQuery 2.1.0 was modified a couple of days ago, and they changed their directories. As this looks quite unstable, we downgraded to JQuery 2.0.3. See [#124](https://github.com/jhipster/generator-jhipster/issues/124)

How to upgrade
------------

Update your version of JHipster with:

```
npm update -g generator-jhipster
```

And then you can update your project when you run again

```
yo jhipster
```

Help and bugs
--------------

If you find any issue with this release, don't hesitate to:

- Contact [@jhipster](https://twitter.com/jhipster) on Twitter
- Add a bug on our [bug tracker](https://github.com/jhipster/generator-jhipster/issues?state=open)
- Post a question on [Stack Overflow](http://stackoverflow.com/tags/jhipster/info)


text:
---
layout: default
---

# 1997-12-03 - Re: FC: The tensions between Internet advocacy groups

## Header Data

From: Marc Rotenberg<EMAIL_ADDRESS>To: "Daniel J. Weitzner"<EMAIL_ADDRESS>Message Hash: c9dd8a7b31284ad3e77bf39423a611854c4d71dbcb2bfa25aeefadaa1fd3cc48

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1997-12-03 23:12:38 UTC

Raw Date: Thu, 4 Dec 1997 07:12:38 +0800

## Raw message

```
{% raw  %}From: Marc Rotenberg<EMAIL_ADDRESS>Date: Thu, 4 Dec 1997 07:12:38 +0800
To: "Daniel J. Weitzner"<EMAIL_ADDRESS>Subject: Re: FC: The tensions between Internet advocacy groups
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Danny -

I think where the free expression groups differ fundamentally
from the position CDT has set out is that we do not believe
that the Net should be dominated by rating systems.

We recognize that parents have some legitimate concerns about
the availability of objectionable material. But we think that
there are alternatives to widespread ratings -- including
learning more about the benefits of the Internet -- that
are preferable.

We also recognize that there is a risk that Congress will try to
pass CDA II. But we believe that it will be difficult for such
an act to survive Constitutional review after Reno v. ACLU.
We are perhaps more concerned that an architecture of ubiquitous
ratings will provide, as Barry Steinhardt said well at the summit,
a blueprint for legislation that would be upheld.

What exactly does CDT plan to say to the enthusiastic member
of Congress who backs your rating plan and wants to see it
enforced with sanctions?

What are your own views about a filtering search engine
that block access to 99% of the references concerning the
"American Red Cross"?

A diversity of rating systems is the not the same as a
diversity of viewpoints. It is rather a diversity of
fears and prejudices. I hope we never see the day
when national organizations are routinely called upon to
draw up lists of what they do not want others to see.
I suspect that those who are concerned about the
future of free expression share this view.

Marc Rotenberg
EPIC

{% endraw %}
```

## Thread

+ Return to [December 1997](/archive/1997/12)

+ Return to "[Declan McCullagh <declan@well.com>](/authors/declan_mccullagh_declan_at_well_com_)"
+ Return to "[Marc Rotenberg <rotenberg@epic.org>](/authors/marc_rotenberg_rotenberg_at_epic_org_)"

+ _Unknown thread root_
  + 1997-12-03 (Thu, 4 Dec 1997 07:12:38 +0800) - Re: FC: The tensions between Internet advocacy groups - _Marc Rotenberg<EMAIL_ADDRESS>    + 1997-12-03 (Thu, 4 Dec 1997 07:31:26 +0800) - [Re: CDT and the Threat of Gov't Intervention](/archive/1997/12/f81100f545316dd71006365271b96a85a160a332da89b9df10dc3857e59da3dc) - _Declan McCullagh<EMAIL_ADDRESS>