text:
# Greetfans Interview - Mini take-home project

This sample shows how to build a coffee roastery themed SaaS platform using [Stripe Checkout](http://stripe.com/checkout) and [Stripe Connect](https://stripe.com/connect), where coffee roasteries can signup to get their website and wholesale shop with just a few clicks. The Roastery platform takes an application fee for every transaction happening on the platform.

Platform owners are on-boarded using [Stripe Connect Standard](https://stripe.com/connect) where they connect their existing Stripe account. When the marketplace accepts funds via card payments, the funds are routed to the seller's Stripe accounts as a part of each marketplace transaction.

See a hosted version of the [https://roastery.stripe.dev](https://roastery.stripe.dev)

Join [Google meet](https://meet.google.com/jbi-jmpx-yap)

<img src="./demo.png" alt="Preview of recipe" align="center">

## Features

- Basic user authentication system.
- Stripe onboarding using Stripe Connect Standard.
- Payments via Stripe Checkout.
- Basic platform website for each seller.
- Custom platform dashboard.

## Architecture

The marketplace is implemented as full-stack application powered by [Next.js](https://nextjs.org/) and contains a React front-end, and a Node.js REST API.

The app renders its React components as both the server and client-side using [isomorphic rendering](https://matwrites.com/universal-react-apps-start-with-next-js/).

![](https://matwrites.com/wp-content/uploads/2017/06/Isomorphic-web-apps.png)

### Technical features

- Authentication system using [JWT tokens](https://jwt.io/) with login and signup pages.
- Storage using [LowDB](https://github.com/typicode/lowdb) to provide a basic local JSON database.
- REST API scaffolding with authentication endpoints for resources like `listings`, `login`, `payouts`, `profile`, `signup`, `transactions`, and `users`.
- Card payments are accepted via [Payment Intents API](https://stripe.com/docs/payments/payment-intents) + [Stripe Elements](https://stripe.com/payments/elements) and is integrated via [`react-stripe-elements`](https://github.com/stripe/react-stripe-elements)

## Getting started

To run this sample locally all you need is checkout the repo and run the app.

You will need a Stripe account with its own set of [API keys](https://stripe.com/docs/development#api-keys), and enable a few features for your Stripe Account.

Don't worry, just follow the steps in this guide.

**1. Clone and configure the sample**

```
git clone https://github.com/sivakoneti/greetfans.git

OR

git clone https://github.com/stripe/stripe-demo-connect-roastery-saas-platform.git
```

**2. Configure Stripe**

The first thing you need to do is to Create a Connect platform. You do that by going to https://dashboard.stripe.com/test/connect/overview.

Once you have registered your Connect platform, you can now generate a Connect User Id. You need this together with your Stripe API keys.

**2.

Copy the .env.example file into a file named .env in the folder of the server you want to use. For example:

```
cp .env.example .env
```

Now copy your Stripe API keys and Connect User id into your `.env` file:

```
STRIPE_PUBLIC_KEY=<replace-with-your-publishable-key>
STRIPE_SECRET_KEY=<replace-with-your-secret-key>
STRIPE_CLIENT_ID=<replace-with-your-connect-client-id>
```

Save the `.env` file and you should be good.

**3. Set A Redirect URI for Stripe Onboarding**

Go to your [connect settings](https://dashboard.stripe.com/settings/applications) to add a redirect uri for Stripe to call back to after a seller onboards with Stripe.

The URI this app uses is [http://localhost:3000/stripe/callback](http://localhost:3000/stripe/callback)

### Using the sample app

1. Run `npm install`
1. Run `npm run dev`
1. You are now ready to use the app running in [http://localhost:3000](http://localhost:3000).
1. The marketplace should be available, and if you go to `/login` you should be able to login as both buyers and sellers using the demo buttons.

## Problem sets

1. Currently, this project has a Basic Authentication system with [JWT tokens](https://jwt.io/) and new users and Platforms are stored in [LowDB](https://github.com/typicode/lowdb) in a basic local JSON (/db/database.json).

P: Change Data Storage to [AWS dynamodb using amplify with GraphQL](https://aws.amazon.com/blogs/mobile/amplify-framework-adds-support-for-aws-lambda-functions-and-amazon-dynamodb-custom-indexes-in-graphql-schemas/) and implement [Firebase Authentication](https://firebase.google.com/docs/auth).

```
Hint1: You are free to use code samples from [Next.js +Firebase authentication](https://github.com/vercel/next.js/tree/canary/examples/with-firebase-authentication).

Hint2: Any two Authentication APIs [Providers integration](https://firebase.google.com/docs/auth) with Google, Facebook, or Twitter.

Note: No duplicate email accounts should be allowed in the platform
```

2. Currently "User Platform settings" [http://localhost:3000/dashboard/settings](http://localhost:3000/dashboard/settings) are disabled to modify.

P: A. Enable "Update settings" Button and add extra fields to change TEL, availble Timings, Support email, Platform logo, Cover picture, and Tag line.

   B. In User "Profile" [http://localhost:3000/profile](http://localhost:3000/profile) add functionality to change Name, and Profile Picture of the User.

Platform logo, Cover picture, Tag line will be displayed in Platform Public URL [http://localhost:3000/p/mission-coffee-co](http://localhost:3000/p/mission-coffee-co)

TEL, Availble Timings, Support email will be displayed in Platform Public URL [http://localhost:3000/p/mission-coffeee-co/contact](http://localhost:3000/p/mission-coffeee-co/contact)

Both "Platform settings" and "Profile" data should be stored in [AWS dynamodb using amplify with GraphQL](https://aws.amazon.com/blogs/mobile/amplify-framework-adds-support-for-aws-lambda-functions-and-amazon-dynamodb-custom-indexes-in-graphql-schemas/)

```
Hint1: To Enable Platform settings -> Update settings Button
Modify: 'publicRuntimeConfig' In next.config.js

    isTestMode:
      // process.env.STRIPE_PUBLIC_KEY &&
      // process.env.STRIPE_PUBLIC_KEY.indexOf('pk') > -1
      false,
    }

Hint2: Data structure and fields same as database.json in /db/database.json from root folder.
```
3. Change Product design template in [http://localhost:3000/p/mission-coffee-co/products](http://localhost:3000/p/mission-coffee-co/products)

- From this design
![image](https://user-images.githubusercontent.com/41994167/103122719-76b52d80-46a7-11eb-8c77-f3d7a45b086a.png)

- To this Design  ( https://github.com/stripe-samples/payment-form-modal )
![image](https://user-images.githubusercontent.com/41994167/103122646-17571d80-46a7-11eb-8646-1fa33378de98.png)

4. Push code to your private repo and deploy in [vercel](https://vercel.com/)

######
Samples fom nextjs https://github.com/vercel/next.js/tree/canary/examples
###### Optional
4. Documentation for each problem set implementation.
5. Fix potential security vulnerabilities in this repository dependencies.

## Project contributor(s)

[@auchenberg-stripe](https://twitter.com/auchenberg)
# greetfans


text:
---
title: "Accounting Metrics"
linkTitle: "Accounting Metrics"
weight:
description: >
  Exposing of Accounting Metrics
---

## Accounting Metrics
Accounting requires that statistics concerning site usage, performance, etc. can be collected. For this the IOP exposes certain metrics which, via an http metrics service, can be gathered periodically by external monitoring services.

The precise metrics that can be monitored are defined in the Reva metrics package.

### Available Accounting Metrics
The following accounting metrics are expected to be available, see metrics interface (https://github.com/cs3org/reva/tree/master/pkg/metrics/reader):

1. Number of users per site
2. Number of groups per site
3. Amount of storage per site

It is up to the site to have the above specified metrics figures ready so the metrics service can serve them using one of the metrics drivers. Currently 2 drivers are implemented: 'dummy', 'json'.

The json driver reads metrics through a json file which needs to be updated continuously by the site to have the latest figures available. The json driver will periodically read the file in order to register the latest figures.

The dummy driver solely exists for demo purposes. It makes the metrics service serve dummy figures.

Which one of the drivers is used by the site is [configurable](#configurations).

### Configuration
Below is a metrics configuration file example that explains the possible options. The configuration concerns the 'http.services.metrics' block:

```
[shared]

[http.services.metrics]
# one of dummy, json.
metrics_data_driver_type = "dummy"
# if left unspecified location /var/tmp/reva/metrics/metricsdata.json is used (for driver type json).
metrics_data_location = ""
# metrics recording interval in milliseconds
metrics_record_interval = 5000

[http.services.prometheus]

[http]
address = "<IP_ADDRESS>:5550"
```
To choose what driver to use specify the ```metrics_data_driver_type``` value using the driver type name. If the json driver is used the driver expects to find the a metrics figures file in [json format](#metrics-figures-file-format-for-json-driver) at location of your choice, by specifying the ```metrics_data_location``` value. If not specified the default location (/var/tmp/reva/metrics/metricsdata.json) is used.

The metrics recording interval can be set using the ```metrics_record_interval``` flag and has a default recording interval of 5 seconds.

#### Metrics figures file format for json driver
The json driver expects to find a json file in the following exact format (with example values). Each property name reflects the specific metric it concerns:
```
{
    "cs3_org_sciencemesh_site_total_num_users": 7000,
    "cs3_org_sciencemesh_site_total_num_groups": 550,
    "cs3_org_sciencemesh_site_total_amount_storage":<PHONE_NUMBER>
}
```
**"cs3_org_sciencemesh_site_total_amount_storage"** is expected to be of type ```byte```.

This file is read periodically (```metrics_record_interval``` [configuration](#configurations) flag) by the json driver.

It is the site's responsibility to update this file periodically with the latest figures.

### Formats and Exporting
The metrics package uses [OpenCensus](https://opencensus.io/) for implementation of the statistical data types and exporting of the metrics in [Prometheus](https://prometheus.io/) exposition format.

A response of the http metrics service to a single GET metrics request contains all defined metrics.

repository: nsimbi/sciencemesh

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: nsimbi/sciencemesh


text:
# AVAPI
### Get data from Alpha Vantage into python.

Authors:
- Ole Olaussen<EMAIL_ADDRESS>- Xuan Ling<EMAIL_ADDRESS>

## Documentation

For more complete documentation, please go to [ReadTheDocs](https://avapi.readthedocs.io).

There are other python wrappers for the alpha vantage API, such as [alphavantage](https://pypi.org/project/alphavantage/), [alpha-vantage-downloader](https://pypi.org/project/alpha-vantage-downloader/), [alpha_vantage](https://pypi.org/project/alpha_vantage/) and [alphavantage-wrapper](https://pypi.org/project/alphavantage-wrapper/). They all have in common that they have different functions for each of the data types that Alpha Vantage offers. This may be less practical when downloading multiple data types at multiple resolutions in one session. Avapi has a single function that can download any data type from Alpha Vantage: avapi.get_data() takes \*\*kwargs as input and outputs a  dictionary, unless datatype="csv" is given, in which case a csv file is saved. If the data type is time series, avapi.to_df() converts it to a Pandas data frame. The intention is a simple and flexible way to get data from Alpha Vantage into python.

### Installation

```python
pip install avapi
```

### Before use

Follow instructions on the [Alpha vantage](https://www.alphavantage.co) website to get a free API-key.  The [docs](https://www.alphavantage.co/documentation/) provide all necessary info for à la carte downloading of historical data and indicators. Please checkout Alpha Vantage [support](https://www.alphavantage.co/support/#support) and read through the [Frequently Asked Questions](https://www.alphavantage.co/support/#support).

#### Examples

The "demo" api-key only works for these specific examples. If you modify the code you also need to provide your own api-key.

##### Single download

```python
import avapi as aa
import pandas as pd

data = aa.get_data(function='VWAP', symbol='MSFT',
                   interval='15min', apikey='demo')

df = aa.to_df(data)
df.head()
```

##### Multiple files download

There are limits for free accounts: up to 5 API requests per minute and 500 requests per day.  In loops, if you don't incorporate time.sleep(), you might get errors.

```python
import avapi as aa
import pandas as pd
from time import sleep

data_path = 'data/'

data_calls = [

{
 'function': 'TIME_SERIES_DAILY',
 'symbol': 'MSFT',
 'apikey': 'demo',
 'datatype': 'csv',
},
{
 'function':'TIME_SERIES_INTRADAY',
 'symbol': 'MSFT',
 'interval': '5min',
 'apikey': 'demo',
 'datatype': 'csv',

}
]

for call in data_calls:
    save_to = data_path + call['function'] + '_' + call['symbol'] + '.csv'
    data = aa.get_data(save_to=save_to, **call)
    sleep(15)
```

##### Unexpected results

If you get unexpected results, you may check the latest, original response from the Alpha Vantage server in the following way:

```python
response = aa.response()
print(response)
```

## Contribute

- Issue Tracker: https://github.com/ekkobit/avapi/issues
- Source Code: https://github.com/ekkobit/avapi
- Documentation: https://avapi.readthedocs.io

license: MIT

repository: ekkobit/avapi

repo_name: ekkobit/avapi


text:
# zcash-automation

## Overview

[Zcash](https://z.cash) is a censorship resistant, fixed supply, privacy preserving cryptocurrency. Launched in 2016, Zcash is the first cryptocurrency to operationalize zero knowledge cryptography to create a secure, private, digital currency,

This repository contains tools and frameworks to enable provisioning, configuration, management and monitoring of Zcash infrastructure in public clouds.

The first provider targeted is [Google Cloud Platform](https://cloud.google.com/), using [Terraform](https://www.terraform.io/).

See the [README](gcp/terraform/README.md) in the gcp/terraform folder to get started.

repository: nathan-at-least/zcash-automation

branch_name: refs/heads/main

gha_license_id: MIT

repo_name: nathan-at-least/zcash-automation


text:
### WDL Analysis Research Pipelines

The WDL Analysis Research Pipelines (WARP) repository is a collection of cloud-optimized pipelines for processing biological data from the Broad Institute Data Sciences Platform and collaborators.

WARP provides robust, standardized data analysis for the Broad Institute Genomics Platform and large consortia like the Human Cell Atlas and the BRAIN Initiative. WARP pipelines are rigorously scientifically validated, high scale, reproducible and open source, released under the [BSD 3-Clause license](https://github.com/broadinstitute/warp/blob/master/LICENSE).

### Pipeline releases
All pipeline releases are listed on the WARP [releases page](https://github.com/broadinstitute/warp/releases). To discover and search releases, use the WARP command-line tool [Wreleaser](https://github.com/broadinstitute/warp/tree/develop/wreleaser).

### WARP Dockers and custom tools in warp-tools repository
All Dockers and custom tools used for WARP's WDL Workflows are maintained in a separate repository, [warp-tools](https://github.com/broadinstitute/warp-tools).

### WARP documentation

Read more about our pipelines and repository on the [WARP documentation site](https://broadinstitute.github.io/warp/).

To contribute to WARP, please read the [contribution guidelines](https://broadinstitute.github.io/warp/docs/contribution/README).

[![Build Status](https://img.shields.io/github/workflow/status/broadinstitute/warp/Deploy%20WARP%20Website?label=Website&logo=github&style=flat-square)](https://github.com/broadinstitute/warp/actions?query=workflow%3A%22Deploy+WARP+Website%22)

repository: broadinstitute/warp

branch_name: refs/heads/develop

gha_language: WDL

repo_name: broadinstitute/warp


text:
# Changelog

## [v1.5.0](https://github.com/solidusio/solidus_dev_support/tree/v1.5.0) (2020-06-13)

[Full Changelog](https://github.com/solidusio/solidus_dev_support/compare/v1.4.0...v1.5.0)

**Fixed bugs:**

- Fix formatting typo in readme [\#117](https://github.com/solidusio/solidus_dev_support/pull/117) ([aldesantis](https://github.com/aldesantis))

**Removed:**

- Remove deprecated bin/r and bin/sandbox\_rails binaries [\#118](https://github.com/solidusio/solidus_dev_support/pull/118) ([aldesantis](https://github.com/aldesantis))

## [1.4.0] - 2020-06-05

### Added

- Added a "Usage" section to the default readme

### Changed

- Restored `bin/rails` and renamed the context specific bins to `bin/rails-engine` and `bin/rails-sandbox`
- Adjusted the readme structure with better formatting and grammar
- Moved the RuboCop `AllCops/Exclude` statement back to the internal configuration

### Deprecated

- Deprecated `bin/r` in favor of `bin/rails-engine` and `bin/sandbox_rails` in favor of `bin/rails-sandbox`

## [1.3.0] - 2020-05-22

### Added

- Ignored `.rvmrc`, `.ruby-version` and `.ruby-gemset` by default in extensions
- Added deprecation warning when extensions don't support Zeitwerk

### Changed

- Updated the extension template to use latest (0.5.X) solidus_support
- Set Ruby 2.5+ as the minimum Ruby version in generated extensions

### Removed

- Removed Stale from the default extension configuration

## [1.2.0] - 2020-04-24

### Changed

- Updated the extension template with the latest modifications

## [1.1.0] - 2020-03-06

### Added

- Made Git ignore `sandbox` in generated extensions
- Added support for specifying `SOLIDUS_BRANCH` in the sandbox

### Changed

- Split `bin/rails` into `bin/r` and `bin/sandbox_rails`

### Fixed

- Fixed the sandbox Gemfile not including Solidus

## [1.0.1] - 2020-02-17

### Fixed

- Fixed missing factory definitions when using `modify` on Solidus factories

## [1.0.0] - 2020-02-07

### Added

- Added a binstub for `rake` to the extension generator
- Added the ability for the generator to reuse existing data for the gemspec

### Fixed

- Fixed Dependabot throwing an error because of `eval_gemfile` in the Gemfile

## [0.6.0] - 2020-01-20

### Added

- Added support for a local Gemfile for local development dependencies (e.g. 'pry-debug')
- Added a `bin/sandbox` script to all extension for local development with `bin/rails` support.

### Changed

- The default rake task no longer re-generates the `test_app` each time it runs.
  In order to get that behavior back simply call clobber before launching it:
  `bin/rake clobber default`

### Fixed

- Fixed generated extensions isolating the wrong namespace

## [0.5.0] - 2020-01-16

### Added

- Added `--require spec_helper` to the generated `.rspec`

### Fixed

- Replaced "Spree" with "Solidus" in the license of generated extensions

### Changed

- Updated gem-release to use tags instead of branches for new releases

## [0.4.1] - 2020-01-15

### Fixed

- Fixed the generated RuboCop config inheriting from this gem's dev-only config
- Fixed the generated extension not requiring the `version` file
- Fixed the generator not properly marking `bin/` files as executable

## [0.4.0] - 2020-01-10

### Added

- Enforced Rails version depending on the Solidus version in generated Gemfile
- Made Git ignore `spec/examples.txt` in generated extensions
- Added the ability to run `solidus extension .` to update an extension

### Changed

- The `solidus` executable is now solely managed by Thor and is open to extension by other gems

### Fixed

- Fixed generated extensions using an old Rakefile
- Fixed some RuboCop offenses in the generated files
- Fixed the `bin/setup` script calling a non-existing Rake binary

### Removed

- Removed RuboCop from the default Rake task
- Removed the `-v` option from the `solidus` executable
- Removed the factory_bot gem from the Gemfile

## [0.3.0] - 2020-01-10

### Added

- Adopted Ruby 2.4+ as the minimum Ruby version in generated extensions
- Added `bin/console`, `bin/rails` and `bin/setup` to generated extensions
- Added some Bundler gemspec defaults to generated extensions
- Configured the default Rake task to run generate the test app before running RSpec

### Changed

- Updated solidus_support to 0.4.0 for Zeitwerk and Rails 6 compatibility
- Updated the `solidus` executable to only rely on Thor and be open to extension by other gems

### Removed

- Removed solidus_support as a dependency

### Fixed

- Fixed `extension:test_app` not going back to the root after execution

## [0.2.0] - 2019-12-16

### Added

- Adopted [Apparition](https://github.com/twalpole/apparition) as the deafult JS driver for Capybara
- Fixed window size to 1920x1080px in feature specs
- Added [Stale](https://github.com/apps/stale) to automatically mark GitHub issues as stale

### Changed

- Disabled all `Metrics` cops except for `LineLength`
- Set `Layout/AlignArguments` cop to `with_fixed_indentation`
- Disabled `Layout/MultilineOperationIndentation` cop
- Renamed the project to SolidusDevSupport (was SolidusExtensionDevTools)

### Fixed

- Fixed Chrome not starting in headless mode

## [0.1.1] - 2019-11-11

### Fixed

- Fixed `rails_helper` not working due to `SolidusDevSupport` not being available

## [0.1.0] - 2019-11-11

Initial release.

[Unreleased]: https://github.com/solidusio/solidus_dev_support/compare/v1.4.0...HEAD
[1.4.0]: https://github.com/solidusio/solidus_dev_support/compare/v1.3.0...v1.4.0
[1.3.0]: https://github.com/solidusio/solidus_dev_support/compare/v1.2.0...v1.3.0
[1.2.0]: https://github.com/solidusio/solidus_dev_support/compare/v1.1.0...v1.2.0
[1.1.0]: https://github.com/solidusio/solidus_dev_support/compare/v1.0.1...v1.1.0
[1.0.1]: https://github.com/solidusio/solidus_dev_support/compare/v1.0.0...v1.0.1
[1.0.0]: https://github.com/solidusio/solidus_dev_support/compare/v0.6.0...v1.0.0
[0.6.0]: https://github.com/solidusio/solidus_dev_support/compare/v0.5.0...v0.6.0
[0.5.0]: https://github.com/solidusio/solidus_dev_support/compare/v0.4.1...v0.5.0
[0.4.1]: https://github.com/solidusio/solidus_dev_support/compare/v0.4.0...v0.4.1
[0.4.0]: https://github.com/solidusio/solidus_dev_support/compare/v0.3.0...v0.4.0
[0.3.0]: https://github.com/solidusio/solidus_dev_support/compare/v0.2.0...v0.3.0
[0.2.0]: https://github.com/solidusio/solidus_dev_support/compare/v0.1.1...v0.2.0
[0.1.1]: https://github.com/solidusio/solidus_dev_support/compare/v0.1.0...v0.1.1
[0.1.0]: https://github.com/solidusio/solidus_dev_support/releases/tag/v0.1.0

\* *This Changelog was automatically generated by [github_changelog_generator](https://github.com/github-changelog-generator/github-changelog-generator)*


text:
# Feedback Identification Algorithm for Embedded Applications
This repository will house the final project of Embedded Electronics Group B.

## Team Members:
Domenic Ferri - Contact Email<EMAIL_ADDRESS>Alex Cannan - Contact Email<EMAIL_ADDRESS>
## Course:
Fall 2018 ENGN2912B - Scientific Programming in C++

Data Submitted: December 2018

# Introduction

## Project Overview:

When a microphone is in the presence of a speaker, this creates a feedback loop. This feedback loop
can create adverse artifacts, in the form of tonal feedback, based on the frequency response of the
devices and the geometry of the setup. We believe that a system can be developed for embedded use
that will be able to identify feedbacking frequencies using a sophisticated method and eliminate them.

There are many reasons of motivation for our project. This first is that standard feedback eliminators use a
threshold magnitude in order to identify feedback. This means that if the amplitude of a particular frequency
is above a choosen amount, then it is labeled as feedback and removed. The problem is that this leads to alot
of inacuracies and plenty of healthy musical frequiencies getting removed as well. The reason is that amplitude
alone is not enough information to know if a frequency is undergoing feedback or not. Instead, a good feedback
identification algorithm must also consider the rate of change in amplitude from sample to sample (swelling),
the harmonic structure, spectral width, and lifespan of the offending frequencies. Our algorithm assigns a probabilty
to a frequency that represents how likely it is that it is undergoing feedback based on the following 5 checks:

#### (1) SNR Check

- This component will exclude any peaks below a certain signal to noise threshold

#### (2) Swell Check

- This component will assign a probability to frequencies that are increasing over time, indicating a feedback loop

#### (3) Harmonic Check

- This component will check if frequencies with a non-zero probability have harmonics--feedback tones should be isolated, while instrument tones will have harmonics

#### (4) Spectral Width Check

- This component will look at the frequencies in close proximity to the budding feedback and identify if they are growing at a similar rate. This would indicate wide-band feedback, and must be dealt with a wider band-stop filter

#### (5) Sustain Check

- This component will keep tabs on possible feedback peaks, and then increase their probability if they're sustained for an extended period. It is possible that feedback can reach a maximum intensity based on the external system, so this will take that into account.

By taking into consideration all these factors, the likelyhood of errors is much less than using only a single
threshold.

Feedback eliminators that have these more advanced identification algorithms are often unaccessable due to price
or portability. If a person wants to record feedbackless audio, they would likely have to go to a recording studio
or buy and setup expensive and complex exquipment. Our feedback identifier is built on and operates on a Respberry Pi
making it a very inexpensive and portable feedback eliminator. The Raspberry Pi proves convient with its audio ports
that allow connecting a headset and microphone to record, playback, save, and remove feedback with a powerful algorithm
from the confort of thier own home and without breaking the bank.

## Goals and Objectives:

#### Goal 1:

- The ability to read in and parse a .wav file for header and sound data. (Completed)

#### Goal 2:

- The ability to take the FFT of sound data samples from a file. (Completed)

#### Goal 3:

- The ability to process the FFT to identify offending frequencies. (Completed)

#### Goal 4:

- GUI Interface that allows the user to input algorithm variables, select a file for processing, and output any error messages. (Completed)

#### Goal 5:

- To display a plot of the results: A spectogram showing the frequencies identifies as feedback. (Completed)

#### Goal 6:

- The ability to eliminate the feedback. (Not Completed)

#### Goal 7:

- The ability to use the identifaction and elimination algorithims on live microphone input from the Pi. (Not Completed)

# Software Architectual Design

The software contains the following files:

- FileReader.cpp and FileReader.h: Responsable for reading and parsing a .wav file. Input a file location and outputs an int vector containing the audio data.
- FFTAnalyzer.h: Uses the kiss_fft130 FFT library to compute the FFT of the audio data. Takes as input an int vector and outputs a 2D vector containing the FFT for each sample.
- FeedbackID.cpp and FeedbackID.h: Impliments the five feedback checks and assigns a feedback liklihood probabilty to each frequency for every sample. Takes as input the 2D FFT vector and outputs at 2D vector of probabilities.
- gnuplot_i.hpp: C++ interface for gnuplot.
- analyzerwindow.cpp and analyzerwindow.h: Contains the QT GUI implimentation.
- main.cpp: Calls the QT interface
- WorkingFeedbackGUI.pro: qmake file to compile the project
- kiss_fft130: Included external library that computes the FFT.

## Required External Libraties:

 - Kiss_fft130 (included)
 - Boost Version 1.63.0
 - GNUPlot
 - QT Version 5.7.0

## Functional Block Diagram:

![functional](https://user-images.githubusercontent.com/43046820/50324604-da4f6380-04ad-11e9-9df9-6440393386ee.PNG)

## UML Diagram:

![uml](https://user-images.githubusercontent.com/43046820/50324573-aecc7900-04ad-11e9-99a5-5a35193e6f62.PNG)

# Interface Descriptions

## Graphical Interface

  - The graphical interface has been created using QT Version 5.7.0. It consist of a simple GUI that allows the user to browse for a .wav file, select the weights for each of the checks, choose the analysis period, and show a progress bar. It also consists of two buttons, one that calls the feedback identification algorithm with the chosen user inputs, and one that closes the program. If the file path inputted does not exist, or it is not of proper .wav format, then an error message is shown, and the user will be able to select another file. The code structure of the GUI makes it easy to add future features as they are implemented.

## Data Visualization

  - Using the Gnuplot library and a Gnuplot C++ interface, we are able to plot the results of the feedback identification. The plotted results are in the form of a spectrogram that plots the FFT spectrum as sample number (x-axis), verses frequency (y-axis), verses frequency magnitude (z-axis in color). Over the spectrogram, red highlights are placed over the spectrogram plot that shows how high the probabilities of feedback for each frequency component are. The reader the component is, the higher the probability that the frequency is undergoing feedback. This allows the user to see both the spectrogram of the audio data and feedback probabilities in one plot.

## Exception Handling

  There are two areas of concern where errors can occur that prevent the algorithm from continuing as normal. The first of which dealing with the input .wav file. If an error occurs while reading and processing the file, the file reader retunes the data vector containing a single integer representing the error code to the analyzerwindow which outputs the corresponding error message in a new window. In all cases, the program will not crash and the user will be able to try new inputs. The possible errors regarding the file reader are as follows:

 - Error code 1: The file does not exist or cannot be found.

 - Error code 2: The file is too small to be a .wav file. Occurs if the file size is less than 44 bytes.

 - Error code 3, 4 and 7: The file header does not contain the bytes "RIFF", "fmt", or "data". All wav files should contain these three bytes. In the .wav format, the bytes following these indicators contain valuable information regarding sample rate, sample size, compression, format, and more. We have also found out that sometimes processing wav files in other audio software can sometimes add to move around the header values. Because this is difficult to predict, we do not support files with "RIFF", "fmt", or "data" not in the correct position, which is why we check all three and not just one.

 - Error code 5: The header contains a byte that represents file compression. If the byte reads one, then the file is uncompressed, if the byte is not 1, the file cannot be processed.

 - Error code 6: The header contains a byte that represents the sample format. If the byte reads one, then the file is a mono .wav file, meaning the audio is in the form of a single stream. Some dual channel .wav files can have two channels with alternating samples, which we do not support. If the byte is not read 1, the file cannot be processed.

In all of these situations, the program alerts the user and asks for another file.

The other area where errors can occur is when calculating the probability of feedback for each frequency component using the five checks. Errors can occur when the threshold values and other check attributes are out of range or do not make sense. Originally, we wanted these values to be adjustable from the GUI, however we found a set of constant values that work well for all files. However, incase these values are adjusted within the code, a set of checks were implemented to ensure that the values make sense and will not cause nonsensical results. When these range errors occur, the algorithm proceeds and finishes are normal but a warning is displayed telling the user which value is out of range and that the results may not make sense.

# Testing and Evaluation

## Operating system(s) and software compiler/library version(s) tested

### Raspberry Pi:

  - Raspberry Pi Version 3 Model B+
  - Raspbian Operating System
  - Compliler Version (gcc and g++): 6.3.0
  - QT Version: 5.7.1
  - Boost Version: 1.63.0
  - Gnuplot Version: 5.0

### CCV:

  - Compiler Version (gcc and g++): 7.2
  - QT Version: 5.7.0
  - Boost Version: 1.63.0
  - Gnuplot Version: 4.6

## Description of functional testing to date

### GUI:
The GUI is fully tested and working correctly including:
- Browsing for file.
- Inputting filename and filepath
- Weight Sliders
- Choosable sample size
- All buttons
- Error messages

### File Reader:
The File Reader is fully tested on good and bad files and works correctly:
- Header data is read correctly
- Reads audio format and compression
- Correctly parses and outputs all audio samples
- Rejects non-compatable files
- Checks if file or path exist

### FFT:
On the CCV, the FFTW library is used which outputs the correct values for the FFT of audio samples. It used the inputted GUI variables correctly. On the Raspberry Pi however, we could not get the FFTW library to compile correctly, therefore we used the kiss_fft library, which is outputting the wrong results for a reason we are unsure of. Therefore it is only fully working on the CCV and Windows.

### Feedback Identificaton:
All 5 checks have been tested seperatly by compairing the the checks' output probabilities to the FFT samples. All 5 checks work properly. The weighted average has been tested and is working correctly. The class correctly identifies when algorithm attributes are out of range.

### Gnuplotting:
It was tested that the gunplot matches the data it is given and displays correctly.

## Instructions for compiling and running the software

### CCV:

Download the .modules file

Download the respostory and navigate to the EE-B folder:

```
qmake WorkingFeedbackGUI.pro

make

./WorkingFeedbackGUI
```

Make sure you have Qt, Gnuplot, and Boost libraries installed.

### Raspberry Pi

Unlike the CCV, the Raspberry Pi does not come with all of libraies installed, so the user must first install them.
The operating system that this software was tested on is the Raspbian operating system.

Install the Boost Library version 1.63.0 	boost_1_63_0.tar.bz2 from the following link:

https://www.boost.org/users/history/version_1_63_0.html

Run the bootstrapper:

```
  ./bootstrap.sh
```

Then install:

```
./b2 install
```
Install Gnuplot:

```
sudo apt-get install gnuplot
```
Install Qt and qmake:

```
sudo apt-get install build-essential

sudo apt-get install qtcreator

sudo apt-get install qt5-default
```

Now download the reposatory and navigate to the EE-B folder:

```
qmake WorkingFeedbackGUI.pro

make

./WorkingFeedbackGUI
```

# Conclusions

## Major Accomplishments

-	.WAV File reading
-	Fixed-point and floating-point FFT implementations
-	QT-based GUI with interactivity
-	Adjustable feedback identification model

## Results of the software development effort

 Established a basis for future acoustic feedback research

## Level of Success

Due to external complications, we were not able to complete as much as we had initially planned. However, the end product is a perfect sandbox for the identification algorithm to be tuned further, which lays the groundwork for future development. Considering other forms of success, this was a great opportunity for us to develop our skills as programmers in an industry-like environment.

# Future Work

## Potential future software expansions and software features

-	**Visualization**
o	Logarithmic spectral dimension
o	Automatic axis labels
o	Color Customization
-	**ID Algorithm**
o	More variable customizations
o	Machine learning implementation for optimization
-	**GUI**
o	More options to control FeedbackID unit
o	Integrated visualization component
-	**Input/Output**
o	Support for live signal input and output
o	Ability to output signal to file with feedback filtered
-	**Noise Art**
o	The noiseart branch of the repository could be developed more—it’s based on a broken FFT and produces noisy, colorful patterns.

# Author Contributions

  - Domenic Ferri: Feedback identification, .WAV file parsing
- Alex Cannan: FFT Integration, GUI using Qt, Visualization using gnuplot


text:
> Building digital products and empowering online companies

# Vue Live Demo - SFC Editor

[![npm (scoped with tag)](https://flat.badgen.net/npm/v/@indielayer/vue-live-demo)](https://npmjs.com/package/@indielayer/vue-live-demo)
[![npm](https://flat.badgen.net/npm/dt/@indielayer/vue-live-demo)](https://npmjs.com/package/@indielayer/vue-live-demo)

Vue Live Demo used on Indielayer

DEMO - [https://indielayer.github.io/vue-live-demo/](https://indielayer.github.io/vue-live-demo/)

## Getting Started

Do you want to add to your own projects? There you go:

1. Add this package to your dependencies

```bash
$ npm i @indielayer/vue-live-demo
# or
$ yarn add @indielayer/vue-live-demo
```

2. Usage:

```html
<template>
  <div style="padding-top: 100px">

    <vue-live-demo
      :code="code"
      :show-code="showCode"
      :components="components"
    />

  </div>
</template>

<script>
import VueLiveDemo from '@indielayer/vue-live-demo'

// Components you wish to add on the demo
// import RandomComponent from './RandomComponent.vue'

export default {
  components: {
    VueLiveDemo
  },
  data() {
    return {
      // components you wish to add on the demo
      components: {
        // RandomComponent,
      },
      code: `<template><div>hello</div></template>`,
      showCode: true
    }
  }
}
</script>
```

### Missing features - TODO

- `import` other scripts in the Single File Component

## License

[MIT license](https://github.com/indielayer/vue-live-demo/blob/master/LICENSE) - Indielayer

repository: wwwK/vue-live-demo

repo_name: wwwK/vue-live-demo


text:
# Aspis Nishimura, 1992 GENUS

#### Status
ACCEPTED

#### According to
IRMNG Homonym List

#### Published in
Micropaleontology (New York) 38 (4), 31 December: 358.

#### Original name
null

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
---
title: Impressive Jboss tools on Eclipse Europa
date: 2007-07-24
categories:
- java
- tech
tags:
- eclipse

permalink: impressive-jboss-tools-on-eclipse-europa
---
I gave RedHat Developer Studio (a.k.a Jboss tools)  a quick try and it seems quite promising. I set it up on a brand new Eclipse Europa using [the nightly builds](http://download.jboss.org/jbosstools/builds/nightly/ "Jboss nightly builds")It integrates Exadel Studio for Jsf development, and plugins to develop with your favorite Jboss Enterprise Middleware System  tools and frameworks (hibernate, jbpm , jboss rules, jboss tree and aop cache,Jboss WS (jsr-181)) and off course the brand new Seam. It will offer a complete enterprise grade and open source middleware stack with a nice ide.I am really looking forward to the final release.
Here are some screenshots:

- Hibernate's perspective (using a Jpa persistance unit):

[![Hibernate perspective (Jpa persistance unit)](http://www.dewavrin.info/images/custom/rhds-hibernate.JPG "Hibernate perspective (Jpa persistance unit)")](http://www.dewavrin.info/images/custom/rhds-hibernate.JPG)

- Facelet design/source view
[![](http://www.dewavrin.info/images/custom/jsf_facelets_visual.JPG)](http://www.dewavrin.info/images/custom/jsf_facelets_visual.JPG "Exadel")

repository: lucdew/blog

extension: markdown

repo_name: lucdew/blog


text:
[Documentation](https://v4f.js.org/docs/introduction/get-started) | [Exemples](https://v4f.js.org/docs/introduction/examples) | [API Reference](https://v4f.js.org/docs/api-reference/api) | [Need help ?](https://v4f.js.org/help)
## Description

A javascript library for validation that encourages rapid development and clean code, unlike other validation libraries v4f is designed from the ground up to be adaptable for any context, and it takes care of all your validation in different environments (client, server, native).

You can use  **V4f**  together with ([react.js](https://reactjs.org/),  [angular.js](https://angular.io/),  [vue.js](https://vuejs.org/),  [jquery](https://jquery.com/)) or with any web framework.

### Why

why new validation library where they exist several good ones around, sure you are completely right. but the problem with those libraries is that almost all of the theme focus in data validation and they forget the key reason why we do validation for, is that we desire to guide our users by showing them what they missing or what they doing wrong with  some pieces of information, but sadly  you end up with generic messages errors or writing code on  the top of this libraries every time you use them.

**V4F** comes to solve this problem by focusing on those two features validations and failures messages, **V4F** comes with easy and powerful syntax that feels more human that everyone can understand with more than 40+ built-in rules.

### Out of the box

-  **Schema** : v4f use the concept of the schema types to indicate your rules that will be checked later were we need it, this notion is powerful it lets you create complex rules ones and use it multiple types.

-  **Nested schema** : with v4f you can use a schema that already created inside other schemas to create complex validation.

-  **Related field** : validate fields that related or depends on each other easily with a simple syntax.

-  **Single field** : Validate only one field from schema very useful in situations like instead field validation feedback.

-  **Async-sync** : Validate your schema in asynchronous or synchronous way.

## Getting started

### Syntax overview
```javascript
import { Schema, Field } from "v4f";

const User = Schema({
 username: Field()
  .string()
  .alphaNum()
  .required(),
 email: Field()
  .string()
  .email()
  .required(),
 password: Field()
  .string()
  .min(6)
  .max(20)
  .not.equals(["#username"])
  .not.equals(["#email"])
  .required(),
 cPassword: Field()
  .string()
  .equals(["#password"])
  .required()
});

const result = User.validate(data);

```

The above schema defines the following constraints:
-   username :
    -   Must be string
    -   Must be alpha numeric
    -   Required
-   email :
    -   Must be string
    -   Must be valid email
    -   Required
-   password :
    -   Must be string
    -   At least 6 characters long but no more than 20
    -   Must not be equals to username and email
    -   Required
-   cPassword :
    -   Must be string
    -   Must equals to password
    -   Required

## Instalation

To install the stable version:
```sh
$ npm install v4f
```
This assumes you are using [npm](https://www.npmjs.com/) as your package manager.

or

```sh
$ yarn add v4f
```

If you you use [yarn](https://yarnpkg.com/) as package your package manager.

## Usage

### Commonjs
```javascript
var v4f = required("v4f");

const User = v4f.Schema({// Your schema here});
```
### ES6
```javascript
import {Schema, Field} from "v4f";

const User = Schema({// Your schema here});

```
Read the [Usage Guide](https://v4f.js.org/docs/guides/intro) on our website for detailed instructions on how to use the library.

1.  Fork on GitHub
2.  Make changes to your own fork
3.  Submit a Pull request so that we can review your changes

### Test
 ```sh
 $ yarn test
 ```

### Linter
  ```sh
 $ yarn lint
 ```
## Maintainers

-   [reyx7](https://github.com/reyx7)  -  **Nassih Soufiane**  (author)

## License (MIT)

```
MIT License

Copyright (c) 2019 soufiane nassih<EMAIL_ADDRESS>
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.

```


text:
# CLI REPL Code Evaluation

This document describes the evaluation of user code in the [CLI REPL](../packages/cli-repl),
i.e. what happens when the user types `db.coll.find({})` in the CLI REPL and hits enter.

## Involved Components

### Async REPL
The [`async-repl`](../packages/cli-repl/src/async-repl.ts) is responsible for setting up the Node.js
`REPLServer` that `mongosh` is using for the CLI. Most notabily we customize the `REPLServer.eval` function
to disable certain default REPL behavior and set up customized interrupt and error handling.

### Mongosh Node REPL
The [`MongoshNodeRepl`](../packages/cli-repl/src/mongosh-repl.ts) is our main interface and orchestrator for the CLI. However it does not do any I/O
on its own but relies on an external I/O provider. It initializes and manages the Shell API abstraction
as well as handles things like access to the history or startup messages.

### Shell Evaluator
The [`ShellEvaluator`](../packages/shell-evaluator) is an intermediate package also used by non-CLI uses of the shell and is responsible
for correctly transforming user input before evaluation. It relies on the `async-rewriter2` for input
transformation.
The Shell Evaluator also detects linux-commands like `show dbs` and triggers their execution without further code transformation or evaluation.

### Async Rewriter
The [`async-rewriter2`](../packages/async-rewriter2) transforms code written in a synchronous way into
code with automatically inserted `await` statements to resolve promises returned by the Shell API.

## Execution

1. User enters `db.coll.find({})` and hits enter.
2. The `REPLServer.eval` function is called which is customized in [`async-repl`](../packages/cli-repl/src/async-repl.ts).
3. The customized `eval` function triggers [`MongoshNodeRepl.eval`](../packages/cli-repl/src/mongosh-repl.ts).
4. `MongoshNodeRepl` forwards the user input to [`ShellEvaluator.customEval`](../packages/shell-evaluator/src/shell-evaluator.ts).
5. `ShellEvaluator.customEval` calls `ShellEvaluator.innerEval`:
   1. For linux-style commands, e.g. `show dbs`, processing is immediately triggered and the result is returned up the chain.
   2. For JavaScript user input:
      1. `ShellEvaluator` calls the `async-rewriter` to rewrite user input.
      2. Rewritten user input is now evaluated in the current Shell API context using the _original, non-modified_ `REPLServer.eval`
	 function that has been passed down.
      3. The evaluation result is returned up the chain.

See also the following diagram which additionally includes important events emitted during the execution.

![](cli-code-evaluation.png)

repository: mongodb-js/mongosh

gha_language: TypeScript

repo_name: mongodb-js/mongosh


text:
# web-osc.stahllabs.io

quick test for [osc.js](https://github.com/colinbdclark/osc.js/)

## installation

    yarn install

## run

    npm start

## usage

in the arduino folder you find an example for using open sound control with ESP8266 based boards. the arduino patch is using my [osc library](https://github.com/stahlnow/OSCLib-for-ESP8266).

## future

this migth evolve into a little osc web application in the future.


text:
# Runway Model Template

> DEPRECATION NOTICE: This repository has been deprecated. The functionality described below has been sunset and models can no longer be ported to Runway at this time.

[![RunwayML Badge](https://open-app.runwayml.com/gh-badge.svg)](https://open-app.runwayml.com/)

This repository contains an example model template that can be used as reference when porting machine learning models to [Runway](https://runwayml.com/). This template uses the Runway Model SDK Python module, check out the [module documentation](https://sdk.runwayml.com) for more info.

> See the *Importing Models into Runway* [tutorial](https://learn.runwayml.com/#/how-to/import-models) for a walk-through illustrating how to port a model to Runway.

Each Runway model consists of two special files:

- [`runway_model.py`](runway_model.py): A Python script that imports the runway module (SDK) and exposes its interface via one or more `@runway.command()` functions. This file is used as the **entrypoint** to your model.
- [`runway.yml`](runway.yml): A configuration file that describes dependencies and build steps needed to build and run the model.

## The `runway_model.py` Entrypoint File

The [`runway_model.py`](runway_model.py) entrypoint file is the file the Runway app will use to query the model. This file can have any name you want, but we recommend calling it `runway_model.py`.

### Basic Structure

All Runway models expose a standard interface that allows the Runway desktop application to interact with them over HTTP. This is accomplished using three functions: `@runway.setup()`, `@runway.command()`, and `runway.run()`.

```python
import runway
from runway.data_types import number, text, image
from example_model import ExampleModel

# Setup the model, initialize weights, set the configs of the model, etc.
# Every model will have a different set of configurations and requirements.
# Check https://sdk.runwayml.com/en/latest/runway_module.html to see a complete
# list of supported configs. The setup function should return the model ready to
# be used.
setup_options = {
    'truncation': number(min=5, max=100, step=1, default=10),
    'seed': number(min=0, max=1000000)
}
@runway.setup(options=setup_options)
def setup(opts):
    msg = '[SETUP] Run with options: seed = {}, truncation = {}'
    print(msg.format(opts['seed'], opts['truncation']))
    model = ExampleModel(opts)
    return model

# Every model needs to have at least one command. Every command allows to send
# inputs and process outputs. To see a complete list of supported inputs and
# outputs data types: https://sdk.runwayml.com/en/latest/data_types.html
@runway.command(name='generate',
                inputs={ 'caption': text() },
                outputs={ 'image': image(width=512, height=512) })
def generate(model, args):
    print('[GENERATE] Ran with caption value "{}"'.format(args['caption']))
    # Generate a PIL or Numpy image based on the input caption, and return it
    output_image = model.run_on_input(args['caption'])
    return {
        'image': output_image
    }

if __name__ == '__main__':
    # run the model server using the default network interface and ports,
    # displayed here for convenience
    runway.run(host='<IP_ADDRESS>', port=8000)
```

See the [`example_model.py`](example_model.py) file for the simple `ExampleModel` class used in the example above.

## The `runway.yml` Config File

Each Runway model must have a [`runway.yml`](runway.yml) configuration file in its root directory. This file defines the steps needed to build and run your model for use with Runway. This file is written in YAML, a human-readable superset of JSON. Below is an example of a `runway.yml` file. This example file illustrates how you can provision your model’s environment.

```yaml
version: 0.1
python: 3.6
entrypoint: python runway_model.py
cuda: 9.2
framework: tensorflow
files:
    ignore:
        - image_dataset/*
build_steps:
    - pip install runway-python==0.1.0
    - pip install -r requirements.txt
```

## Testing your Model

While you're developing your model it's useful to run and test it locally.

```bash
## Optionally create and activate a Python 3 virtual environment
# virtualenv -p python3 venv && source venv/bin/activate

# Install the Runway Model SDK (`pip install runway-python`) and the Pillow
# image library, used in this example.
pip install -r requirements.txt

# Run the entrypoint script
python runway_model.py
```

You should see an output similar to this, indicating your model is running.

```
Setting up model...
[SETUP] Ran with options: seed = 0, truncation = 10
Starting model server at http://<IP_ADDRESS>:8000...
```

You can test your model once its running by POSTing a caption argument to the the `/generate` command.

```bash
curl \
    -H "content-type: application/json" \
    -d '{ "caption": "red" }' \
    http://localhost:8000/generate
```

You should receive a JSON object back, containing a cryptic base64 encoded URI string that represents a red image:

```
{"image": "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQ..."}
```

repository: runwayml/model-template

gha_language: Python

repo_name: runwayml/model-template


text:
# Description

**Type:** Distributed
**Requires CredSSP:** No

This resource sets the client callable settings for the web application.
It can set the proxy libraries and specific properties for the client
callable settings. The resource can for example be used to increase the
timeout for client code, and to enable the tenant administration
functionality.

Tenant administration functionality enables client code to work with
the namespace Microsoft.Online.SharePoint.Client.Tenant from the
assembly with the same name. This enables client code to create site
collection, list all site collections, and more.

In order to use the tenant administration client code a site collection
within the web application needs to be designated as a tenant
administration site collection. This can be done using the SPSite
resource setting the AdministrationSiteType to TenantAdministration.
Use this site collection when creating a client side connection.

More information about the tenant can be found in a [blog
post]
(https://blogs.msdn.microsoft.com/vesku/2015/12/04/sharepoint-tenant-csom-object-support-in-sharepoint-2013-and-2016/)
by Vesa Juvonen. In another [blog post]
(https://blogs.msdn.microsoft.com/vesku/2014/06/09/provisioning-site-collections-using-sp-app-model-in-on-premises-with-just-csom/)
he goes into more details of
the setup and architecture, and includes sample code for how to use.

NOTE:
Proxy library used for enabling tenant administration:

**SharePoint 2013** (Requires mininum April 2014 Cumulative Update):
Microsoft.Online.SharePoint.Dedicated.TenantAdmin.ServerStub
, Version=<IP_ADDRESS>, Culture=neutral, PublicKeyToken=71e9bce111e9429c

**SharePoint 2016/2019**:
Microsoft.Online.SharePoint.Dedicated.TenantAdmin.ServerStub
, Version=<IP_ADDRESS>, Culture=neutral, PublicKeyToken=71e9bce111e9429c

In both version set the SupportAppAuthentication property to true.

NOTE2:
An IIS reset needs to be performed on all servers in the farm after
modifying the registered proxy libraries.

repository: ykuijs/SharePointDsc

gha_language: C#

repo_name: ykuijs/SharePointDsc


text:
scrapejs
========

A web scraping framework for node

## Introduction

Powerful, easy to use web scraping framework, built on top of request, cheerio, and xpath. Support both xpath and jQuery selectors.

## Install

npm install scrapejs

## Samples
```javascript
var sp = require('scrapejs').init({
	cc: 2, // up to 2 concurrent requests
	delay: 5 * 1000 // delay 5 seconds before each request
});

sp.load('https://www.google.com/search?q=scraping')
.then(function($){
	$.q("//h3[@class='r']/a").forEach(function(node){
		var res = {
			title: node.textContent,
			url: node.x("./@href")
		}
		console.log(res);
	})
})
.fail(function(err){
	console.log(err);
})

```

## License

(The MIT License)

Copyright (c) 2013 Cung Nguyen<EMAIL_ADDRESS>
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.

THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 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.

repository: kbenrafik/scrap

repo_name: kbenrafik/scrap


text:
# Lab 02 Materials

Instructions for Lab 02 are in this [.md file](https://github.com/THOMASELOVE/431-2020/blob/master/labs/lab02/lab02.md)

## After the Lab

- [Answer Sketch](https://github.com/THOMASELOVE/431-2020/tree/master/labs/lab02/sketch) (available in R Markdown and PDF)
- A video recording (nearly 15 minute .mp4) of Dr Love demonstrating the real-time use of R Studio to do (part of) Lab 02 is [now available on our Shared Google Drive](http://bit.ly/431-2020-Love-does-Lab02). This may be especially helpful to those of you having trouble saving your .Rmd and .HTML files or working with R Projects.


text:
# RuboCop AST

[![Gem Version](https://badge.fury.io/rb/rubocop-ast.svg)](https://badge.fury.io/rb/rubocop-ast)
[![CI](https://github.com/rubocop/rubocop-ast/workflows/CI/badge.svg)](https://github.com/rubocop/rubocop-ast/actions?query=workflow%3ACI)
[![Test Coverage](https://api.codeclimate.com/v1/badges/a29666e6373bc41bc0a9/test_coverage)](https://codeclimate.com/github/rubocop/rubocop-ast/test_coverage)
[![Maintainability](https://api.codeclimate.com/v1/badges/a29666e6373bc41bc0a9/maintainability)](https://codeclimate.com/github/rubocop/rubocop-ast/maintainability)

Contains the classes needed by [RuboCop](https://github.com/rubocop/rubocop) to deal with Ruby's AST, in particular:

* `RuboCop::AST::Node` ([doc](docs/modules/ROOT/pages/node_types.adoc))
* `RuboCop::AST::NodePattern` ([doc](docs/modules/ROOT/pages/node_pattern.adoc))

This gem may be used independently from the main RuboCop gem. It was extracted from RuboCop in version 0.84 and its only
dependency is the [parser](https://github.com/whitequark/parser) gem, which `rubocop-ast` extends.

## Installation

Just install the `rubocop-ast` gem

```sh
gem install rubocop-ast
```

or if you use bundler put this in your `Gemfile`

```ruby
gem 'rubocop-ast'
```

## Usage

Refer to the documentation of [`RuboCop::AST::Node`](docs/modules/ROOT/pages/node_types.adoc) and [`RuboCop::AST::NodePattern`](docs/modules/ROOT/pages/node_pattern.adoc)

See the [docs site](https://docs.rubocop.org/rubocop-ast) for more details.

### Parser compatibility switches

This gem, by default, uses most [legacy AST output from parser](https://github.com/whitequark/parser/#usage), except for the following which are set to `true`:
* `emit_forward_arg`
* `emit_match_pattern`

The main `RuboCop` gem uses these defaults (and is currently only compatible with these), but this gem can be used separately from `RuboCop` and is meant to be compatible with all settings. For example, to have `-> { ... }` emitted
as `LambdaNode` instead of `SendNode`:

```ruby
RuboCop::AST::Builder.emit_lambda = true
```

## Contributing

Checkout the [contribution guidelines](CONTRIBUTING.md).

## License

`rubocop-ast` is MIT licensed. [See the accompanying file](LICENSE.txt) for
the full text.

repository: collabnix/dockerlabs

gha_language: PHP

repo_name: collabnix/dockerlabs


text:
# Search-Tap

![banner (1)](https://user-images.githubusercontent.com/56020411/127701851-2abcf11a-48f4-4b71-8100-4d7688940831.png)

## Inspiration

As developers, most of our time goes into searching stuff and finding out out the functions and syntax of a particular tech stack on the web, because let's face it, WE CANNOT REMEMBER THE SYNTAX OF EVERY LANGUAGE WE WORK IN!

What do we do when we need to google an error or find out the correct way to use a particular function? We paste our 'string' onto Google's search bar and then open up the top 5-6 search result on new tabs hoping to find the answers to our queries.

Sometimes, it may happen that we are reading some documentation and there comes a keyword/function in our way which needs to be understood to go further on understanding about what we initially were reading about!

Now let's think this way, what if we provide you with a feature, where you can just highlight the text you want to search, right click and choose among various options on which platform you would like to find the answer to your question?

Yes you heard that right, Search-Tap let's you do that and helps you save a lot of searching seconds while you're in your develpoer mode. Not only when you're develpoing stuff, but this can be used by all the people wherever they want!

## Table of Contents
* [Introduction](#introduction)
* [Prototypes](#prototypes)
* [Installation](#installation)
* [Features](#features)
* [Contributors](#contributors)

## Introduction:
Search Tap is a browser plugin that is a one stop reasearch work solution for developers and students.
- Quick search option via right click on different platforms.
- A toggle button to serve search option to you on only those websites where you really want to
- A bookmark like feature to save some of your favourite websites which you might use daily or have to log on to on a daily basis for work!
- No need to open millions of tabs and windows now to search data which you don't know. Just use the SEARCH ALL option and get the search results for the same data on different platforms on just 1 TAB! Isn't that a totally new user experience??

## Prototypes:
![wireframe-1](https://user-images.githubusercontent.com/56020411/128554440-abf71347-6d3a-406e-bdf3-421bde012e90.png)

### Github Projects :
![image](https://user-images.githubusercontent.com/45617530/128562230-4a06c8d4-354f-4466-9fde-4fc70cbf3921.png)

## Installation

1. Clone the repository
```sh
git clone https://github.com/KUHOO-S/Selection-Helper.git
```
2.  Enable developer mode in Chrome/Firefox browser and upload the folder
4. Refresh the extension and all tabs which might be currently open in your web browser
5. Pin the extension on the top left corner for accessing pop-up functionalities

![image](https://user-images.githubusercontent.com/45617530/129410775-262c39e5-e191-4696-b7f8-bf4aa6a65b1f.png)

### Features
Selection Tap is a context search based extension, that eases the developer's work by adding some quick featues
1. SEARCHING
    - While developing, our extension provides easy exploration of the selected text thus saving time on copy pasting & searching on 'n' websites.
    - When we right click on the selected text, we get an option bar with 4 different exploration tabs i.e google, stackoverflow, etc.
    - User has automated search results for the selected text in a seperate tab without hindering the existing chrome tab.

2. IFRAME
    - Inorder to find answers to short questions or finding meanings to small queries, we introduced the 'iframe'.
    - Iframe enables you to open a small window on the same screen giving you the desired result for the selected text.
    - Iframe shows all results from google in a small window that does not interfere with the current tab.

3. COPY & PASTE
    - For quick copying all the tabs currently opened and pasting them into a clipboard.
    - When we click the 'paste' button, all the tabs copied in clipboard will automatically open in chrome.
    - We can also paste the tabs in notepad or any other platform as urls.

4. INTEGRATING WITH TWILLIO
    - We can also mail the copied tab's url to a specific person by mentioning their email address in the email section.
    - This feature is added with intergrating twillio sendgrid in our chrome extension.
    - ![image](https://user-images.githubusercontent.com/45617530/128563414-8174cfc5-e7a5-462c-92f3-576577e1fe2b.png)

5. DEFAULT
    - Default is added in the pop-up box for changing the settings in the toogle button to add/ remove any particular option bar.

## Contributors

Thanks goes to these wonderful people :

KUHOO-S
💻 📖

Osinsaini
💻 🎨

Ananya0504
💻 🎨

repository: KUHOO-S/Selection-Helper

repo_name: KUHOO-S/Selection-Helper


text:
# NAMD-xtb-QMMM-interface

Connect NAMD and Grimme's xtb program

See namd-xtb.py for details

We would appreciate citations to the following paper if you use this in your publication:
Fu et al. Acc. Chem. Res. 2019, 52, 3254–3264

This software is under the MIT License


text:
#Check Local Disk Space

###Pre-requisites

Excel 2016

###Examples

1. Download "Excel 2016 New Charts.docx" and "Excel Template.xlsx."

          The Excel 2016 New Charts.docx will explain the process of creating a Treemap or Sunburst chart in Excel.

          The Excel Template.xlsx is the template containing the PivotTable.

2. Open a PowerShell console.

          From the Run dialog type PowerShell and press Enter.

3. Change the directory to the location where the PowerShell Script is saved.

          Example: cd C:\PowerShellScripts

4. Run the Script.

          Type . .\Check-DiskSpace.ps1

          By including the additional period before the relative script path you are 'Dot-Sourcing'
          the PowerShell function in the script into your PowerShell session which will allow you to
          run the function 'Get-ModernOfficeApps' from the console

5. A folder called "FolderData.csv" containing the results will be copied to Public\Documents.

6. Open "Excel Template.xlsx", click the Data Tab and under Connections choose Refresh All.

7. Follow the instructions in "Excel 2016 New Charts.docx" to insert the data into a Treemap or Sunburst chart.

gha_language: Visual Basic


text:
---
layout: page
title: A Public Talk on Something in Particular about Bears
author: Student One
---

## Contents
{:.no_toc}

* ToC
{:toc}

---

## Introduction

It is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout. The point of using Lorem Ipsum is that it has a more-or-less normal distribution of letters, as opposed to using 'Content here, content here', making it look like readable English. Many desktop publishing packages and web page editors now use Lorem Ipsum as their default model text, and a search for 'lorem ipsum' will uncover many web sites still in their infancy.[^fn1] Various versions have evolved over the years, sometimes by accident, sometimes on purpose (injected humour and the like).

## Paragraphs

There are many variations of passages of Lorem Ipsum available, but the majority have suffered alteration in some form, by injected humour, or randomised words which don't look even slightly believable. If you are going to use a passage of Lorem Ipsum, you need to be sure there isn't anything embarrassing hidden in the middle of text. All the Lorem Ipsum generators on the Internet tend to repeat predefined chunks as necessary, making this the first true generator on the Internet.
>It uses a dictionary of over 200 Latin words, combined with a handful of model sentence structures, to generate Lorem Ipsum which looks reasonable. The generated Lorem Ipsum is therefore always free from repetition, injected humour, or non-characteristic words etc.

[^fn2]

## Concluding Remarks

Contrary to popular belief, Lorem Ipsum is not simply random text.  Richard McClintock, a Latin professor at Hampden-Sydney College in Virginia, looked up one of the more obscure Latin words, consectetur, from a Lorem Ipsum passage, and going through the cites of the word in classical literature, discovered the undoubtable source. Lorem Ipsum comes from sections 1.10.32 and 1.10.33 of "de Finibus Bonorum et Malorum" (The Extremes of Good and Evil) by Cicero, written in 45 BC. This book is a treatise on the theory of ethics, very popular during the Renaissance. The first line of Lorem Ipsum, "Lorem ipsum dolor sit amet..", comes from a line in section 1.10.32.

The standard chunk of Lorem Ipsum used since the 1500s is reproduced below for those interested. Sections 1.10.32 and 1.10.33 from "de Finibus Bonorum et Malorum" by Cicero are also reproduced in their exact original form, accompanied by English versions from the 1914 translation by H. Rackham.

## Footnotes
[^fn1]: The bugle is a small trumpet implicated in the military industrial complex.
[^fn2]: My favorite thing about this image is the masterful brushstrokes.


text:
---
id: installation
title: Installation
---

## Dependencies

We use package managers to resolve third-party library dependencies.

### macOS

You will need Xcode with command line tools installed.  To get the command line tools, use:
```
xcode-select --install
```

Install dependencies using homebrew:
```
brew install autoconf automake libtool python3
brew install boost jsoncpp
```
For App Bundle support `brew install protobuf` is also required.

### Ubuntu/Debian (64-bit)
Base requirements are automake & libtool, GCC >= 7, Python >= 3.6 and Boost >= 1.71.0, as well as
development versions of `iberty`, `jemalloc`, `jsoncpp`, `lz4`, `lzma`, and `zlib`. `Protobuf` >= 3.0 is required if optimizing an App Bundle.
#### Ubuntu 18.04+, Debian 10(Buster)+
The minimum supported Ubuntu version is 18.04. The minimum supported Debian version is 10.

A [convenience script](https://github.com/facebook/redex/blob/master/setup_oss_toolchain.sh)
will set up the build environment. This may include downloading Python 3.6 and Boost 1.71.0
on older OS versions.
```
sudo ./setup_oss_toolchain.sh
```
After the script, please run `sudo ldconfig` if it throws an error about loading shared libraries for running protoc.

### Experimental: Windows (64-bit) with MSYS2

You need [MSYS2](https://www.msys2.org/#installation) to build `redex-all` (only MingW-w64 is supported) and [Python 3.6+](https://www.python.org/downloads/windows/) to run `redex.py`.

Install the build requirements in an MSYS or MingW64 shell:
```
pacman -Syuu && pacman -Sy make mingw-w64-x86_64-boost mingw-w64-x86_64-cmake mingw-w64-x86_64-gcc mingw-w64-x86_64-jsoncpp mingw-w64-x86_64-make
```

If you do not use Git on Windows directly, you may install and use it under MSYS2:
```
pacman -S git
```

### Experimental: Windows 10 (64-bit)

You need Visual Studio 2017. Visual Studio 2015 is also possible, but a couple of C++ compile errors need to be fixed. We use [vcpkg](https://github.com/Microsoft/vcpkg) for dependencies. Install vcpkg from their [document](https://github.com/Microsoft/vcpkg):

```
cd c:\tools
git clone https://github.com/Microsoft/vcpkg.git
cd vcpkg
.\bootstrap-vcpkg.bat
.\vcpkg integrate install
```
Install necessary libraries with `x64-windows-static`:
```
.\vcpkg install boost --triplet x64-windows-static
.\vcpkg install zlib --triplet x64-windows-static
.\vcpkg install jsoncpp --triplet x64-windows-static
.\vcpkg install mman --triplet x64-windows-static
```

## Download, Build and Install

Get ReDex from GitHub:
```
git clone https://github.com/facebook/redex.git
cd redex
```

Now, build ReDex using autoconf and make.
```
autoreconf -ivf && ./configure && make
sudo make install
```

Alternatively, to enable protobuf to support App Bundles, please use:
```
autoreconf -ivf && ./configure --enable-protobuf
make
sudo make install
```

For protobuf installed in the default system (Homebrew) search path (e.g /usr/local/bin), `--enable-protobuf` is sufficient to trigger the build. Otherwise, specify the protobuf installation path for the autoconf:
```
autoreconf -ivf
./configure --with-protoc=/path/to/protoc --with-protolib=/path/to/protobuf_libs --with-protoheader=/path/to/protobuf_headers --enable-protobuf
make
sudo make install
```

*If your build machine has lots of RAM (on the order of 2-4GB per core), using
Make parallelism can speed up the build (e.g., `make -j4`). However, the C++
compilers are very memory hungry and this needs to be finely tuned on many
systems.*

### Experimental: Windows (64-bit) with MSYS2

The MSYS2 build relies on CMake. In a MingW64 shell:
```
# Assumes you want to use Git under MSYS. Else skip to below.
git clone https://github.com/facebook/redex.git
cd redex
# Assumes you are in the redex directory
mkdir build-cmake
cd build-cmake
cmake -G "MSYS Makefiles" ..
make
```
*If your build machine has lots of RAM (on the order of 2-4GB per core), using
Make parallelism can speed up the build (e.g., `make -j4`). However, the C++
compilers are very memory hungry and this needs to be finely tuned on many
systems.*

You may check whether the produced binary seems in a working condition:
```
# In the MingW64 shell:
./redex-all.exe --show-passes
# Or in a standard Windows command prompt in the same directory
redex-all.exe --show-passes
```
The output should show a large number of included passes, at the time of writing 81.

Bundling the `redex-all` binary with the python scripts is not supported on Windows. Manually copy the binary into the same directory as `redex.py` and use `redex.py` that way, or ensure that `redex.py` is called with the `--redex-binary` parameter:
```
python redex.py --redex-binary PATH_TO_BINARY [...]
```

### Experimental: CMake for Mac, Linux, and Windows

Alternatively, build using CMake. Note that the current `CMakeLists.txt` only implements a rule for `redex-all` binary. We will support installation and testing soon.

Generate build files. By default, it uses Makefile:
```
# Assume you are in redex directory
mkdir build-cmake
cd build-cmake
# .. is the root source directory of Redex
cmake ..
```

If you prefer the ninja build system:
```
cmake .. -G Ninja
```

On Windows, first, get `CMAKE_TOOLCHAIN_FILE` from the output of `"vcpkg integrate install"`, and then:
```
cmake .. -G "Visual Studio 15 2017 Win64"
 -DVCPKG_TARGET_TRIPLET=x64-windows-static
 -DCMAKE_TOOLCHAIN_FILE="C:/tools/vcpkg/scripts/buildsystems/vcpkg.cmake"
```

Build `redex-all`:

```
cmake --build .
```

On Windows, you may build from Visual Studio. `Redex.sln` has been generated.

You should see a `redex-all` executable, and the executable should show about 45 passes.

```
./redex-all --show-passes
```

## Test
Optionally, you can run our unit test suite.  We use gtest, which is automatically
downloaded when testing (or by invoking a setup script directly).

Note: Testing is currently not supported for CMake-based builds.

### Dependencies
Some ReDex tests require a Java environment and Android compiler tooling. If a JDK and the
Android SDK are available on the machine, ensure that `javac` and `dx` are available on
the `PATH`. Otherwise, install those dependencies.

For Ubuntu/Debian, this may for example be done with
```
sudo apt-get install -y --no-install-recommends dalvik-exchange openjdk-8-jdk-headless
sudo ln -s /usr/bin/dalvik-exchange /usr/local/bin/dx
```

### Execute
Run tests with
```
make -j check
```
*If your build machine has lots of RAM (on the order of 2-4GB per core), using
Make parallelism can speed up the build and testing (e.g., `make -j4`). However,
the C++ compilers are very memory hungry and this needs to be finely tuned on
many systems.*

repository: facebook/redex

repo_name: facebook/redex


text:
# 02-promisify

This sample demonstrates how to *promisify* a Node.js-style callback-based function.

## Run

To run the example launch:

```bash
node index.js
```

gha_language: JavaScript


text:
###### Signal Simulation
I implemented the possibility to generate simulated signals for evaluation of the filters on realistic data.
|<img src = "./img/exemplary_generic.png">|
|:---:|
| Exemplary simulated signal|
```matlab
% you can create a signal with a generic configuration
[signal,echt]  = generate.recording('generic')
```
You can also adapt or define directly your own setup parameters:
```matlab
clear setup
setup.NoiseLevel        = 0.1;

setup.erpMagnitude      = 2; % sum of eoModulation and tacsModulation(1)

% tacs parameters
setup.tacsFreq          = 10;
setup.tacsMagnitude     = 20;
setup.tacsSaturate      = 1; %saturation level in percent
setup.tacsDistort       = 0.2; %periodic signal distortion
%setup.tacsDistort       = 0; %no distortion
setup.tacsPhase         = 'random';
%setup.tacsPhase         = 0; %fixed phase -> phase-dependent ERP

% random fluctuation of the artifact amplitude.
% implemented as a Ornstein–Uhlenbeck, i.e. AR (1), process
setup.tacsModulation    = [1,.5]; %variability, stiffness
% setup.tacsModulation    = [0,1]; %no variability, perfect stiffness

% event-locked modulation
setup.eoFreq            = 10;
setup.eoModulation      = 1;
setup.eoPhase           = 'random';

% signal recording parameters
setup.Fs                = 1000; %in Hz
setup.L                 = 4; %Duration of trial in seconds

[signal,echt,tacs]  = generate.recording(setup)
% signal is the signal as it would be recorded
% (black trace in figure)
% echt is a matrix with 2 rows
% first row is the erp (red trace in figure)
% second row the event-induced oscillations
% tacs is the (stationary, undistorted, sinusoidal)
% stimulator current signal (gray trace in figure)
```
Consider that when tacsPhase and eoPhase as well tacsFreq and eoFreq are identical, they are phase and frequency-matched. Their superposition can be interpreted as event-related exogenous impedance modulation but also as entrainment of an endogenous event-related oscillation. Whether this is an artifact or a signal is a matter of perspective.

repository: agricolab/ARtACS

gha_language: Matlab

repo_name: agricolab/ARtACS


text:
# AnotherBird
This is an educational proyect.
This Game is built with Phaser on Ionic app.

It consists of a bird that can fly from one side of the screen to the other at a fixed height by exploding balloons of different colors to get points.
Your ranking will be saved in your device to improve, don't forget to take the star balloon to fly faster!

# Instalation
Clone the repository
Install dependencies:

```
npm install
```
To execute it in local run the ionic serve
```
ionic serve
```
and open it in movile format, in chrome just right-click, "Insepect" and "Toggle device toolbar"

repository: hpromero/AnotherBird

repo_name: hpromero/AnotherBird


text:
---
title: Meeting API Reference

language_tabs:
  - shell
  - javascript

toc_footers:
  - Documentation Powered by Slate

includes:
  - errors

search: true
---

# Introduction

Welcome to the Meeting Monitor API! You can use our API to access Meeting Monitor API endpoints, which can get information on our the information about meetings/client meetings in our database.

This example API documentation page was created with [Slate](https://github.com/tripit/slate). Feel free to edit it and use it as a base for your own API's documentation.

# Authentication

## Login.

You must use the login to access various sort of dashboards from the Meeting Monitor Backend.
The api endpoints will be accessible only after a valid login is done and valid access token is created.

````javascript
var xhttp = new XMLHttpRequest();
var example = {
    "username":"<some random username>",
    "password":"some password"
};
xhttp.open("POST", "http://<Api-base-endpoint>/login", true);
xhttp.send(example);
````
```shell
curl
    -H "Accept: application/json"
    -H "Content-type: application/json"
    -X POST
    -d '{"username":"<username>","password":"<password>"}'
    http://<your-base-api-endpoint>/login
```

### Http Request

` POST http://<Api-base-endpoint>/login `

### Request Body

Parameter | Default | Description
--------- | ------- | -----------
username | <not-empty(String)> | Indicates the username of the user.
password | <not-empty(String)> | Indicates the password of the user.

### Response

```json
{
  "accessToken":"random-string-values",
  "expiresIn":"timeStamp",
  "reloadToken":"token-to-reload-the-auth-token"
}
```

You must store the result access tokens in the localStorage or an device bound database and attach it with every request to access data from the server.

# Meetings

## Get All Kittens

```shell
curl "http://example.com/api/kittens"
  -H "Authorization: meowmeowmeow"
```

```javascript
const kittn = require('kittn');

let api = kittn.authorize('meowmeowmeow');
let kittens = api.kittens.get();
```

> The above command returns JSON structured like this:

```json
[
  {
    "id": 1,
    "name": "Fluffums",
    "breed": "calico",
    "fluffiness": 6,
    "cuteness": 7
  },
  {
    "id": 2,
    "name": "Max",
    "breed": "unknown",
    "fluffiness": 5,
    "cuteness": 10
  }
]
```

This endpoint retrieves all kittens.

### HTTP Request

`GET http://example.com/api/kittens`

### Query Parameters

Parameter | Default | Description
--------- | ------- | -----------
include_cats | false | If set to true, the result will also include cats.
available | true | If set to false, the result will include kittens that have already been adopted.

Remember — a happy kitten is an authenticated kitten!

## Get a Specific Kitten

```shell
curl "http://example.com/api/kittens/2"
  -H "Authorization: meowmeowmeow"
```

```javascript
const kittn = require('kittn');

let api = kittn.authorize('meowmeowmeow');
let max = api.kittens.get(2);
```

> The above command returns JSON structured like this:

```json
{
  "id": 2,
  "name": "Max",
  "breed": "unknown",
  "fluffiness": 5,
  "cuteness": 10
}
```

This endpoint retrieves a specific kitten.

Inside HTML code blocks like this one, you can't use Markdown, so use <code> blocks to denote code.

### HTTP Request

`GET http://example.com/kittens/<ID>`

### URL Parameters

Parameter | Description
--------- | -----------
ID | The ID of the kitten to retrieve

# Users

## Get Users
This will give you a list of all the users matching to the string parameter you gave.

```javascript
var xhttp = new XMLHttpRequest();
var userSearch = {
  "searchUser":"<random-substring>"
};
xhttp.onreadystatechange = function() {
    console.log(JSON.parse(xhttp.responseText));
};
xhttp.open("GET", "http://<Api-base-endpoint>/users", true);
xhttp.setRequestHeader("accessToken","token that is retreived from the inbound database")
xhttp.send(userSearch);
```
```shell
curl
    -H "Accept: application/json"
    -H "Content-type: application/json"
    -H "accessToken: random accessToken "
    -X GET
    -d '{"searchUser":"<non-empty-string>"}'
    http://<your-base-api-endpoint>/login
```

### Http Request

` GET http://<base-api-endpoint>/users`

### Request Body

Parameter | Default | Description
--------- | ------- | -----------
searchUser | <not-empty(String)> | Indicates the substring of the name of the user.

### Special Request Headers

Header | Default | Description
--------- | ------- | -----------
accessToken | <not-empty(String)> | Indicates the accessToken of the User.

### Response

```json
[
  {
    "name":"string",
    "avatar":"static-file-location",
    "designation":"String",
    "desc":"short-desc"
  }
]
```

repository: lokiiarora/slate

gha_license_id: NOASSERTION

repo_name: lokiiarora/slate


text:
---
last_modified_on: "2020-07-13"
$schema: "/.meta/.schemas/highlights.json"
title: "Require `encoding` option for console and file sinks"
description: "The `encoding` option is now required for these sinks"
author_github: "https://github.com/binarylogic"
pr_numbers: [1033]
release: "0.6.0"
hide_on_release_notes: false
tags: ["type: breaking change", "domain: sinks", "sink: console", "sink: file"]
---

The dynamic `encoding` concept in Vector was confusing users, so we've made
it required and explicit. Simply add `encoding = "json"` to your `console` and
`file` sinks.

## Upgrade Guide

Make the following changes in your `vector.toml` file:

```diff title="vector.toml"
 [sinks.console]
   type = "console"
+  encoding = "json"

 [sinks.file]
   type = "file"
+  encoding = "json"
```

That's it!

repository: alakahakai/vector

repo_name: alakahakai/vector


text:
### Exceptions
![Exception Classes](img/java-exceptions-diagram.png "Core Exceptions")

Base exception classes `CheckedException` and `UncheckedException` are
clearly named with the intention for use with custom exception types for clear class hierarchy.

repository: kkorbacz/java-extended

repo_name: kkorbacz/java-extended


text:
# The Corridor

[The Corridor](https://github.com/xavimarin35/CorridorPrototype) is a Level Design prototype under the topic "Corridor" made by Joan Barduena and Xavi Marín, students of [CITM](https://www.citm.upc.edu/) in Barcelona during our [Game Design and Development Bachelor's Degree](https://www.citm.upc.edu/cat/estudis/grau-videojocs-bcn/), with [Unreal Engine 4](https://www.unrealengine.com/en-US/).

## Usage

### Installation

Download the zip file and unzip it. Open the folder, execute the .exe and enjoy our prototype!

IMPORTANT: *Do not modify, change or add any folder or file (unless specified) as you might not be able to execute the application.*

## Authors

### Joan Barduena

- Github: [Lidux](https://github.com/joanbarduena)
- LinkedIn: [Joan Barduena](https://www.linkedin.com/in/joanbarduena/)

### Xavi Marín

- Github: [xavimarin35](https://github.com/xavimarin35)
- LinkedIn: [Xavi Marín](https://www.linkedin.com/in/xavi-marin-sola/)

## Contact

 Don't hesitate to visit:
 - Our repository: https://github.com/xavimarin35/CorridorPrototype

 Or contact us:
 - Joan Barduena<EMAIL_ADDRESS> - Xavi Marín<EMAIL_ADDRESS>


text:
# 3rd-maps-utils (AndroidX)

>This project is derived from [Maps SDK for Android Utility Library](https://github.com/googlemaps/android-maps-utils), and relies on Huawei HMS Core [Map Kit](https://developer.huawei.com/consumer/en/hms/huawei-MapKit) and [Site Kit](https://developer.huawei.com/consumer/en/hms/huawei-sitekit/).

## Usage of library module
1. Open Gradle, click library->Tasks->build->assemble.
2. After Run, find `3rd-maps-utils-2.2.2-yyyyMMdd.aar` file in `library/build/outputs/aar/` path.
3. Copy `3rd-maps-utils-2.2.2-yyyyMMdd.aar` file to your own `app/libs/` path.
4. Add codes below in project build.gradle file.
```java
allprojects {
	repositories {
		...
		flatDir {
			dirs 'libs'
		}
	}
}
```
5. Add codes below in app build.gradle file.
```java
dependencies {
    implementation(name: '3rd-maps-utils-2.2.2-yyyyMMdd', ext: 'aar')
    ...
}
```

## Usage of demo module
1. [Configuring App Information in AppGallery Connect](https://developer.huawei.com/consumer/en/doc/development/HMSCore-Guides/android-sdk-config-agc-0000001061560289)
2. [Adding the AppGallery Connect Configuration File of Your App](https://developer.huawei.com/consumer/en/doc/development/HMSCore-Guides/android-sdk-integrating-sdk-0000001061671869#EN-US_TOPIC_0000001061671869__section4256162815361)
3. Replace your own applicationId in `build.gradle(Module:3rd-maps-utils.demo)`, it should be the same as the **package_name** in `agconnect-services.json` file.
4. Replace your own **signingConfigs** in `build.gradle(Module:3rd-maps-utils.demo)`, it should be the keystore file used to generate the **SHA-256 value** configured on AppGallery Connect.
5. Replace your own **API_KEY** in `HeatmapsSiteDemoActivity.java`, it should be encoded by using `URLEncoder.encode("Your apiKey", "UTF-8")` method.


text:
Spree amazon-like dropdown menu
=======================

Provides dropdown taxonomies menu like Amazon's. Based on the [jQuery-menu-aim](https://github.com/kamens/jQuery-menu-aim) plugin.

Demo: https://spreecommerce-demo.herokuapp.com/

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

Add spree_amazon_like_dropdown to your Gemfile:

```ruby
gem 'spree_amazon_like_dropdown', github: 'maginfo-team/spree_amazon_like_dropdown'
```

Bundle your dependencies and run the installation generator:

```shell
bundle
bundle exec rails g spree_amazon_like_dropdown:install
```

Copyright (c) 2015 Maginfo Ltd, released under the New BSD License


text:
---
---

# checkmain.py

```python
def addArrays(x, y):
    z = []
    for i in range(0,len(x)):
        z.append( x[i] + y[i] )

    return z

if __name__ == "__main__":
    # Don't run this code if this script is being
    # imported as a module

    a = [ 1, 2, 3, 4 ]
    b = [ 5, 6, 7, 8 ]

    c = addArrays(a, b)
    print( c )
```

# [Previous](../documenting) [Next](../documenting)


text:
jUnit. Home work 1
===============
1\. Create unit tests
---------------
Create unit tests for ContactApi, ContactIdGenerator.

Code coverage should be over 90%.

2\. Create unit tests
---------------
Create unit tests for ConsoleCalculator.

You should also test Input and Output. Use [System Rules][1] and [Mockito][2]

Code coverage should be over 90%.

[1]: http://stefanbirkner.github.io/system-rules/
[2]: http://site.mockito.org


text:
---
layout: post
title: "MSN AdCenter Screenshots"
date: 2005-03-17 15:46
comments: true
categories: Business
author: Oliver Thylmann
---

Search Engine Lowdown has the [First Screenshots of MSN adCenter](http://www.searchenginelowdown.com/2005/03/first-screenshots-of-msn-adcenter.html) it seems. And they do look pretty nice. Still a question of usability is good but there seem to be some very nice statistics. It also includes audience profiles though it is unclear where that profiling comes from. All in all it seems to be an advanced copy of AdWords and I am looking forward to try it out to see if it beats AdWords in Usability. That's really one of the main problems with Overture's system as they usability (including speed and time to set a campaign live) is so damn poor you tend not to use it.


text:
Twitter_crawler
===============

This should (if finished) fetch your twitter friends (people you follow) to
the 6th degree.

Currently it's just the first thing I ever wrote in erlang, and it just
a simple Twitter API you can play with.

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

I'm using the awesome [rebar](https://github.com/basho/rebar) so just type this:
```
rebar get-deps
rebar compile
```

and then just run the script
```
./twitter.erl
```

Twitter API Key
===============

For this to work you need to register an App and get an API key,
https://apps.twitter.com/

Then create a ```twitter.secret``` JSON file that looks like this:
```json
{
    "APIKey": "YOUR_API_KEY",
    "APISecret": "YOUR_API_SECRET"
}
```


text:
# Example Call To Action Plugin

An example plugin used for conference workshops.

### Requirements

* A local development environment with WordPress installed. Any will do (MAMP, WAMP, Vagrant, DesktopServer, etc).
* A theme activated (the default is fine) with some dummy content populated.

### Setup

* Download the "Example Call To Action" plugin and extract the ZIP file, or clone this repository into the `/wp-content/plugins/` folder
* Install the [Query Monitor](https://wordpress.org/plugins/query-monitor/) plugin from the WP repository.

repository: norcross/example-cta-plugin

repo_name: norcross/example-cta-plugin


text:
Arduino TextMate Bundle 1.0a
============================
[TextMate](http://macromates.com) is the best editor in human history. [Arduino](http://arduino.cc) is the easiest embedded platform to dive into. Why don't the two work together? The Arduino TextMate Bundle solves that glaring error, and the universe is thus balanced.

There are other TextMate bundles out there, but they're mostly over two years old and don't work with new Arduino versions. This project aims to remain up-to-date and make embedded as enjoyable as everything else in TextMate.

The little 'a' in '1.0a' stands for 'alpha'. Read that as "might not work for you". It will grow and improve with time, but for now brace yourself for bugs. That means bug reports, feature requests and patches!

As of 1.0a, the bundle can compiles and uploads to the device, provides access to the documentation and highlights syntax correctly.

Installation
============
1. [Get the latest Arduino](http://arduino.cc/en/Guide/MacOSX). Version 1.0 and later is supported, and it must be installed to /Applications
2. [Get TextMate](http://macromates.com/).
3. [Get the latest Arduino TextMate bundle](https://github.com/nasser/arduino.tmbundle/zipball/v1.0a).
4. Extract the zip file to `~/Library/Application Support/TextMate/Bundles/Arduino.tmbundle`
5. If TextMate was open during this process, click Bundles>Bundle Editor>Reload Bundles
6. Check the 'Default Environment vars' near the top of `~/Library/Application Support/TextMate/Bundles/Arduino.tmbundle/Support/Makefile`.  Any you need to override - especially check the ARDUINO_MCU var - can be added in TextMate's Preferences => Advanced => Shell Variables.

Usage
=====
* **⌘U** Compiles and uploads your sketch to the connected Arduino
* **⌃⌥⌘H** Opens up local HTML documentation on to current word
* **Bundles > Arduino > Watch Serial Port** Opens a terminal window monitoring the serial port.
* **File > New From Template > Arduino > Basic Sketch** Creates a file with a blank basic sketch.

Shell Variables
===============
The compile/upload process can be finely controlled using TextMate's shell variables.

Textmate > Preferences > Advanced > Shell Variables

    Variable
    Value

    BOARD
    The Arduino variant being used. See table below.

	  SERIALDEV
	  We try to guess the correct serial port. If that is not possible, you have to set the correct serial port.
Like: /dev/tty.usbmodem1411

Supported Arduino Boards
========================
Value | Description
------|------------
uno          |Arduino Uno
atmega328    |Arduino Duemilanove w/ ATmega328
diecimila    |Arduino Diecimila or Duemilanove w/ ATmega168
nano328      |Arduino Nano w/ ATmega328
nano         |Arduino Nano w/ ATmega168
mega2560     |Arduino Mega 2560 or Mega ADK
mega         |Arduino Mega (ATmega1280)
leonardo     |Arduino Leonardo
esplora      |Arduino Esplora
micro        |Arduino Micro
mini328      |Arduino Mini w/ ATmega328
mini         |Arduino Mini w/ ATmega168
ethernet     |Arduino Ethernet
fio          |Arduino Fio
bt328        |Arduino BT w/ ATmega328
bt           |Arduino BT w/ ATmega168
LilyPadUSB   |LilyPad Arduino USB
lilypad328   |LilyPad Arduino w/ ATmega328
lilypad      |LilyPad Arduino w/ ATmega168
pro5v328     |Arduino Pro or Pro Mini (5V, 16 MHz) w/ ATmega328
pro5v        |Arduino Pro or Pro Mini (5V, 16 MHz) w/ ATmega168
pro328       |Arduino Pro or Pro Mini (3.3V, 8 MHz) w/ ATmega328
pro          |Arduino Pro or Pro Mini (3.3V, 8 MHz) w/ ATmega168
atmega168    |Arduino NG or older w/ ATmega168
atmega8      |Arduino NG or older w/ ATmega8
robotControl |Arduino Robot Control
robotMotor   |Arduino Robot Motor

Bleeding Edge
=============
For the adventurous

    git clone git://github.com/nasser/arduino.tmbundle.git ~/Library/Application\ Support/TextMate/Bundles/Arduino.tmbundle

Changes
=======
1.0a
----
* Fixed for Arduino 1.0
* Improved local help command
* Changed versioning scheme to match Arduino's. This bundle's version will always be equal to the version of Arduino it is most compatible with.

0.21a
----
* Added snippets for common methods
* Added an Arduino project template
* Altered the monitor script - it's now aware of your USB ports

0.2a
----
* Compile/upload bug fixed
* Syntax highlighting added
* Local help added
* Initial Watch Serial Port implementation
* More intelligent Makefile with environment variable overrides

0.1a
----
* Initial release, basic implementation of compiling/uploading


text:
### ditax_metrics

It is a simple set of erlang modules to collect any custom metrics from your erlang apps. Module works as erlang gen_server, which keeps all your metrics in ets tables.
You can collect metrics for any reasonable period of time. When creating a new metric to store you can set the reset period for this metric. In this case you will get the result for the predefined period (if no other period is defined). Also you can skip the value of metric so that will be always 1 or you can set it in your `inc/2` call.

### How to use

Start the module: `ditax_metrics:start_link([Metric])` where `Metric` can be just a name (atom) or a record `#metric{}`.

If you want to add some default value for the metric's reset use `#metric{period = some_value_in_seconds}`. Besides, if you have this period given, by default you will get the metric value for this exact period.

If you want to add some metrics when the module is already started use `ditax_metrics:add(Metric)` where `Metric` is `atom() | #metric{name = SomeName} | #metric{name = SomeName, period = SomePeriod}`.

To add new value for the metric use `ditax_metrics:inc(MetricName)` where MetricName is `atom()` or `ditax_metrics:inc(MetricName, SomeValue)`.

To get the result use `ditax_metrics:get(MetricName)` or `ditax_metrics:get(MetricName, CustomPeriod)` where CustomPeriod is less than the default period used for creating this metric (if there is one).


text:
# ssh2-config

SSH config reader.

## Installation

```
npm i ssh2-config
```

## Usage

```
const sshConfig = require('ssh2-config');
const { Client } = require('ssh2');

sshConfig({ host: 'example.com', preferSsh2: true }, (err, result) => {
  const c = new Client();
  c.connect(result);
});
```

## sshConfig(options, callback)

### Parameters

- `options.host`
    - A string of the host name to read the setting.
- `options.commandLineOptions`
    - An array of options equivalent to `-o` of `ssh` command.
- `options.userSpecificFile`
    - A path of the configuration file to be read.
- `options.result`
    - The result that was read previously.
- `options.preferSsh2`
    - A boolean value as to whether to return the result corresponding to `ssh2` package.
- `callback(err, result)`
    - A callback called when setting loading is completed, or when an error occurs.

### Result

The `result` argument of `callback` changes properties of the object by `options.preferSsh2`.

If `options.preferSsh2` is truthy, the `result` has the following properties:

- `host`
- `port`
- `username`
- `privateKey`

## sshConfig.sync(options)

Synchronous version of `sshConfig`.

## License

MIT


text:
# GCP4Us | Blog
GCP4Us - Blog and related resources

## 👋 Hi there! Thanks for visiting this page
We are GCP4Us, a project proudly supported by [HildenCo Software](//www.hildenco.com).

In our blog we will discuss everything about the [Google Cloud Platform](//cloud.google.com).

Check our blog at: [gcp4us.com](https://www.gcp4us.com)

# Partner Websites
* [HildenCo | Blog](https://blog.hildenco.com): Blog about development, cloud and open-source software
* [Linux4Us](https://www.linux4us.com): News, tutorials and tips about Linux (under development)
* [Vim4Us](https://www.vim4us.com): Tips in tricks to learn and master Vim (under development)
* [Golang4Us](https://www.golang4us.com): Tips in tricks to learn the Go programming Language (under development)

# 📫 Reaching out...
Reach out to us on [Twitter](https://twitter.com/gcp4us).