text:
# Create CLJS App [![Build Status](https://github.com/filipesilva/create-cljs-app/workflows/Node%20CI/badge.svg?branch=master)](https://github.com/filipesilva/create-cljs-app/actions)

Create ClojureScript apps with a single command.

It is focused on making it easy for JS and React developers to get started with ClojureScript.

Create CLJS App works on Windows, Linux, and macOS.

If something doesn’t work, please [file an issue](https://github.com/filipesilva/create-cljs-app/issues/new).

Heavily inspired on [create-react-app](https://github.com/facebook/create-react-app). A lot of messages are mostly the same for now (create-react-app maintainers: if that's not ok, let me know).

## Quick Overview

```sh
npx create-cljs-app my-app
cd my-app
npm start
```

Then open [http://localhost:3000/](http://localhost:3000/) to see your app.

When you’re ready to deploy to production, create a minified bundle with `npm run build`.

## Creating an App

**You’ll need to have Node 10.16.0 or later version on your local development machine** (but it’s not required on the server). You can use [nvm](https://github.com/creationix/nvm#installation) (macOS/Linux) or [nvm-windows](https://github.com/coreybutler/nvm-windows#node-version-manager-nvm-for-windows) to easily switch Node versions between different projects.

**You'll also need a [Java SDK](https://adoptopenjdk.net/) (Version 8+, Hotspot).**

To create a new app, you may choose one of the following methods:

### npx

```sh
npx create-cljs-app my-app
```
_([npx](https://medium.com/@maybekatz/introducing-npx-an-npm-package-runner-55f7d4bd282b) comes with npm 5.2+ and higher)_

### npm

```sh
npm init cljs-app my-app
```

_`npm init <initializer>` is available in npm 6+_

### Yarn

```sh
yarn create cljs-app my-app
```

_`yarn create` is available in Yarn 0.25+_

It will create a directory called `my-app` inside the current folder.

Inside that directory, it will generate the initial project structure and install the transitive dependencies:

```
my-app
├── README.md
├── package.json
├── node_modules
├── shadow-cljs.edn
├── .gitignore
├── public
|  ├── css
|  |  └── style.css
|  ├── index.html
|  └── favicon.ico
└── src
   ├── app
   |  ├── cards.cljs
   |  ├── core.cljs
   |  ├── hello.cljs
   |  └── hello_cards.cljs
   └── e2e
      └── core.cljs
```

Once the installation is done, you can open your project folder:

```sh
cd my-app
```

Inside the newly created project, you can run some built-in commands:

### `npm start` or `yarn start`

Runs the app in the development mode.

Open [http://localhost:3000](http://localhost:3000) to view it in the browser.
The page will reload if you make edits.

The app uses [Reagent](https://reagent-project.github.io), a minimalistic interface between ClojureScript and React.

You can use existing npm React components directly via a [interop call](http://reagent-project.github.io/docs/master/InteropWithReact.html#creating-reagent-components-from-react-components).

Builds use [Shadow CLJS](https://github.com/thheller/shadow-cljs) for maximum compatibility with NPM libraries. You'll need a [Java SDK](https://adoptopenjdk.net/) (Version 8+, Hotspot) to use it.

You can [import npm libraries](https://shadow-cljs.github.io/docs/UsersGuide.html#js-deps) using Shadow CLJS. See the [user manual](https://shadow-cljs.github.io/docs/UsersGuide.html) for more information.

### `npm run cards` or `yarn cards`

Runs the interactive live development environment.

You can use it to design, test, and think about parts of your app in isolation.

This environment uses [Devcards](https://github.com/bhauman/devcards) and [React Testing Library](https://testing-library.com/docs/react-testing-library/intro).

### `npm run build` or `yarn build`

Builds the app for production to the `public` folder.

It correctly bundles all code and optimizes the build for the best performance.

### `npm test` or `yarn test`, and `npm run e2e` or `yarn e2e`

`test` launches the test runner in the interactive watch mode.

You can use `test:once` instead to run the tests a single time, and `e2e` to run end-to-end tests.

See the ClojureScript [testing page](https://clojurescript.org/tools/testing) for more information. E2E tests use [Taiko](https://github.com/getgauge/taiko) to interact with a headless browser.

### `npm run lint` or `yarn lint`, and `npm run format` or `yarn format`

`lint` checks the code for known bad code patterns using [clj-kondo](https://github.com/borkdude/clj-kondo).

`format` will format your code in a consistent manner using [zprint-clj](https://github.com/clj-commons/zprint-clj).

### `npm run report` or `yarn report`

Make a report of what files contribute to your app size.

Consider [code-splitting](https://code.thheller.com/blog/shadow-cljs/2019/03/03/code-splitting-clojurescript.html) or using smaller libraries to make your app load faster.

### `npm run server` or `yarn server`

Starts a Shadow CLJS background server.

This will speed up starting time for other commands that use Shadow CLJS.

## License

Create CLJS App is open source software [licensed as MIT](https://github.com/filipesilva/create-cljs-app/blob/master/LICENSE).


text:
# Version 0.2.0

This version significantly reworks the internals and provides new
public facing features. This came out of real world experience using
the library in other projects. This release changes two things:

1. `Logger` is **NO LONGER** monkey patched by default
2. Add a formatter that does not include timestamps.

The first point was done to make this library a better citizen in the
ruby community by following this principle: global non-opt-in monkey
patching is bad and should be avoided. Monkey patching in itself is
fine, as long as the developers knows it's happening and has control
over it.

The second point is a minor enhancement but goes a long way in keeping
down the noise. Most distributed logging systems will insert their own
timestamp on all messages. This becomes annoying when your log
messages contain timestamps.  This functionality is available either via
monkey patch or subclass.

## Upgrading from 0.1.x

0.2.x is backward compatible with 0.1.0 depending on how the library
is required. `require 'logger/better'` will keep the 0.1.x behavior.

license: MIT

repository: ahawkins/logger-better

branch_name: refs/heads/master

extension: md

gha_language: Ruby

license_type: permissive

repo_name: ahawkins/logger-better


text:
# Introduction
Mpesa library which you can use with various framework like laravel ,codeigniter ,cakephp and many more
This package seeks to help php developers implement the various Mpesa APIs without much hustle. It is based on the REST API whose documentation is available on https://developer.safaricom.co.ke.

#  Installation using composer
``` bash
  composer require stephencoduor/mpesa
```
Or add the following line to the require block of your `composer.json` file.

```
"stephencoduor/mpesa": "^1.0.*"
```

You'll then need to run `composer install` or `composer update` to download it and have the autoloader updated.

Once Laravel Mpesa is installed, you need to register the service provider. Open up `config/app.php` and add the following to the `providers` key.

```php
'providers' => [
    ...
    Stephencoduor\Mpesa\MpesaServiceProvider::class,
    ...
]
```

> If you use **Laravel >= 5.5** you can skip this step and go to [**`configuration`**](#)

* `Stephencoduor\Mpesa\MpesaServiceProvider::class`

Also, register the Facade like so:

```php
'aliases' => [
    ...
    'Mpesa' => Stephencoduor\Mpesa\Facades\Mpesa::class,
    ...
]
```

## Configuration

You can publish the configuration file using this command:

```bash
php artisan vendor:publish --provider="Stephencoduor\Mpesa\MpesaServiceProvider"
```

A configuration-file named `mpesa.php` with some sensible defaults will be placed in your `config` directory:

```php

#  Usage example

  ```require_once('vendor/autoload.php')```
  use the above statement if it procedural app else if its codeigniter 3.x go config enable $config['composer_autoload'] = 'vendor/autoload.php';
  if vendor is root folder if vendor file are on application it should be $config['composer_autoload'] = true ,
  for laravel and other framework they have no problem

    use Stephencoduor\Mpesa\Mpesa;

A

    $mpesa = new Mpesa();

---------------Now you can call functions on Mpesa as Below ----------------

    echo " Token : " . $mpesa->oauth_token();
    $mpesa = new Mpesa();
    $mpesa->express()->stkPushQuery('ws_CO_DMZ_297481201_09042019174418021');
    $mpesa->express()->stkPush('1','254708374149','pay now','test',''https://example.com/callback_url/);

    $mpesa->c2b()->register_url('https://example.com/$confirmation_url/','https://example.com/validation_url/');
    $mpesa->c2b()->c2bPay('1000', '254708374149', 'account');

    $mpesa->b2c()->b2cSend('200', 'BusinessPayment', '254708374149', 'payment','b2c_timeout','b2c_result'); // last two parameter define callback https://example.com/result_url.php/b2c_timeout/ or https://example.com/result_url/b2c_result/

    $mpesa->b2c()->b2bSend('10000','BusinessPayBill','60000','4','4','paytest','cool','b2b_timeout','b2b_result');

    $mpesa = new Mpesa()
    $mpesa->accountbalance('600443','4','remarks','acc_timeout','acc_result');
    $mpesa->reversal('2','254708374149','1','NCR7S1UXBT','PAY NOW');
    $mpesa->transaction_status('NCR7S1UXBT','254708374149','4','apitest');

 # get responses
    echo $mpesa->getResponseData();

# Callback json data received from safaricom
    for call back you can use you own implementation
    this is for testing.

    use Stephencoduor\Mpesa\Callback;

    $callback = new Callback;
    $callback::processSTKPushRequestCallback();
    $callback::processC2BRequestConfirmation();
    $callback::processC2BRequestValidation();
    $callback::processB2CRequestCallback();
    $callback::processB2BRequestCallback();
    $callback::processAccountBalanceRequestCallback();
    $callback::processReversalRequestCallBack();
    $callback::processTransactionStatusRequestCallback();

  ## Contributing

## Security

## Credits

## License

The MIT License (MIT). Please see [License File](LICENSE.md) for more information.

repository: stephencoduor/mpesa

branch_name: refs/heads/main

gha_license_id: MIT

repo_name: stephencoduor/mpesa


text:
---
title: Architecture deep dive
type: Architecture
---

This document describes the Helm Broker workflow in details, including the logic of its inner components, namely the Controller and Broker.

![Architecture deep dive](./assets/hb-deep-dive.svg)

1. The Controller watches for ClusterAddonsConfiguration (CAC) and AddonsConfiguration (AC) custom resources (CRs).
2. The user creates, updates, or deletes CAC or AC custom resources.
3. The Controller fetches and parses the data of all addon repositories defined under the **spec.repositories** field in a given CR. During this step the Controller:
    - Analyzes fetched addons against errors.
    - Checks for ID duplications under the **repositories** field.
    - Checks for ID conflicts with already registered addons.
4. The Controller saves the fetched addons to the storage.
5. When the first CR appears, the Controller creates a ClusterServiceBroker or a ServiceBroker, depending on the type of the CR. The ClusterServiceBroker or the ServiceBroker provides information about the Broker's endpoint which returns the list of all available services to Service Catalog. There is always only one ClusterServiceBroker per cluster and one ServiceBroker per Namespace, no matter the number of existing CRs. Whenever the list of offered services changes, the Controller triggers Service Catalog to fetch a new list of services from the ClusterServiceBroker or the ServiceBroker.
6. The Broker component fetches addons from the storage and exposes them to Service Catalog.
7. Service Catalog calls the catalog endpoint of the ClusterServiceBroker or the ServiceBroker and creates Service Classes based on the list of registered services.

## Update CRs

There are two cases in which you might want to update your CR:
- Re-fetching addons from a remote server
- Changing repositories URLs

### Re-fetching addons

If you provided changes to your addon on a remote server but the URL did not change, you must re-fetch your changes manually. In such a case, increment the **reprocessRequest** field to explicitly request the reprocessing of already registered and processed CR.

### Changing repositories URLs

If you made any change in your addon's URLs, the update process is triggered automatically and the Controller performs its logic.

## Delete CRs

This is the logic the Controller executes after you delete a given CR:

1. If a given CR is in the **Ready** state, the Controller removes it from the storage.
2. After addons are removed from the storage, the Controller increments the **reprocessRequest** field of all failed CRs that had conflicts with the deleted CR in order to reprocess them.
3. The Controller deletes a [finalizer](https://kubernetes.io/docs/reference/using-api/api-concepts/#resource-deletion) from the given CR.

repository: kyma-project/helm-broker

gha_language: Go

repo_name: kyma-project/helm-broker


text:
# postgis2-96_featureserver
A Dockerfile with setup of postgis2 and featureserver

## Base Docker Image

* [centos:latest](https://hub.docker.com/_/centos/)

## Image Contents

* [postgresql96](https://yum.postgresql.org/repopackages.php#pg96) - database
* [postgis2-96](http://postgis.net) - pgsql extension to support for geographic objects
* [featureserver](http://featureserver.org/index.html) -  RESTful Geographic Feature Service
* [virtualenv](https://virtualenv.pypa.io/en/stable/) - for featureserver's python modules purpose

## The Idea

The idea was to setup a Docker image with installed above components on [amazonlinux](https://hub.docker.com/_/amazonlinux/). Unfortunately there were lot of problems during *postgis2_96* installation, mainly with dependencies.
To prevent time wasting I just switched to ordinary *Centos7* where I did not notice problems like on *amazonlinux*. Of course there were others but more "user friendly" :)

## Knowledge

Below topics were very helpful!

* [Installing pyspatialite](http://blog.oddbit.com/2015/11/17/installing-pyspatialite-on-fedora/)
* [virtualenv - User Guide](https://virtualenv.pypa.io/en/stable/userguide/)

## Work Done

1. Docker image with the latest *Centos7*
2. Installed and configured *postgresql96*
3. Installed *postgis2-96*
4. Installed *featureserver*

## Run with docker-compose

Just run like that:

`docker-compose up`

To rebuild it:

`docker-compose up --build`

## Check if featureserver works

Featureserver is running in the *standalone* mode. Open the web browser and type:

`http://localhost:8080`

You should see in the docker-compose logs:

```
postgis2         | pg_ctl: another server might be running; trying to start server anyway
postgis2         | waiting for server to start....< 2017-04-04 15:12:17.672 UTC >LOG:  redirecting log output to logging collector process
postgis2         | < 2017-04-04 15:12:17.672 UTC >HINT:  Future log output will appear in directory "pg_log".
postgis2         |  done
postgis2         | server started
postgis2         | Creating user "bar"...
postgis2         | CREATE ROLE
postgis2         | Creating database "foo"...
postgis2         | CREATE DATABASE foo;
postgis2         | CREATE DATABASE
postgis2         | Granting access to database "foo" for user "bar"...
postgis2         | GRANT
postgis2         | waiting for server to shut down.... done
postgis2         | server stopped
postgis2         | Starting PostgreSQL 9.6 server...
postgis2         | < 2017-04-04 15:12:20.517 UTC >LOG:  redirecting log output to logging collector process
postgis2         | < 2017-04-04 15:12:20.517 UTC >HINT:  Future log output will appear in directory "pg_log".
featureserver    | <IP_ADDRESS> - - [04/Apr/2017 15:12:24] "GET / HTTP/1.1" 200 35
```

## TODO

1. ~~Create a *docker-compose* file~~
2. Test of *featureserver* features
  * ~~Start the featuresrever~~
  * ~~Connect the featureserver to postgis2~~
3. Find a way to run it on *amazonlinux*
4. Make the image smaller
5. Refactor scripts in the data/ directory

## Acknowledgement

Most of this code was refactored from great [zokeber/docker-postgresql](https://github.com/zokeber/docker-postgresql) repository.

gha_language: Shell


text:
---
title: "About"
date: "2018-07-19"
author: "Radek"
path: "/about"
---

## Hi there

My name is Radek and I'm the author of this starter. I made it to help you present your ideas easier.

We all know how hard is to start something on the web, especially these days.

This starter is pretty basic and covers all of the essentials. All you have to do is start typing!

The starter includes:

- **light/dark mode**, depending on your preferences
- great reading experience thanks to [**Inter UI font**](https://rsms.me/inter/), made by [Rasmus Andersson](https://rsms.me/about/)
- nice code highlighting thanks to [**PrismJS**](https://prismjs.com)
- responsive youtube/vimeo etc. videos thanks to [**gatsby-remark-embed-video**](https://github.com/borgfriend/gatsby-remark-embed-video)

So, there you have it... enjoy!

repository: panr/gatsby-starter-hello-friend

gha_language: JavaScript

repo_name: panr/gatsby-starter-hello-friend


text:
---
title: "Marine Pilot Under Investigation For Flying Invisible Wiener Pattern In Sky"
author: 'geekologie.com'
date: '2018-10-30'
slug: marine-pilot-under-investigati
link: https://geekologie.com/2018/10/marine-pilot-under-investigation-for-fly.php
categories:
- bloglink
tags:
  - geekologiecom
---

A US Marine pilot is currently under investigation after flying in a pattern above the Salton Sea in California's Imperial and Coachella Valleys that very clearly resembles a penis. Just not a very big one, at least by my standards[... <i class="fas fa-external-link-alt"></i>](https://geekologie.com/2018/10/marine-pilot-under-investigation-for-fly.php)

repository: mkearney/data-scribers

repo_name: mkearney/data-scribers


text:
# Code-wars
A set of practice note and source code of solution to Code-wars problem set

# Current rank of Code-wars

[![Generic badge](https://www.codewars.com/users/brianchiang-tw/badges/large)](https://www.codewars.com/users/brianchiang-tw/badges/large)

repository: brianchiang-tw/Code-wars

repo_name: brianchiang-tw/Code-wars


text:
# traffic_light_ssd_fine_detector

This is a traffic light fine detector implementation of MobileNetV2 + SSDLite.

The trained model is based on [pytorch-ssd](https://github.com/qfgaohao/pytorch-ssd).

## Reference

M. Sandler, A. Howard, M. Zhu, A. Zhmoginov and L. Chen, "MobileNetV2: Inverted Residuals and Linear Bottlenecks," 2018 IEEE/CVF Conference on Computer Vision and Pattern Recognition, Salt Lake City, UT, 2018, pp. 4510-4520, doi: 10.1109/CVPR.2018.00474.


text:
# Nutrition Tracker

Nutrition Tracker is a web application that allows users to track and visualize your daily intake of protein, fat, and carbohydrate.
It allows users to choose how many calories and in what macronutrient ratio they wish to consume daily.
It requires users to log thier meals using [FatSecret](http://www.fatsecret.com/) either on the web or through its mobile app.

Uses:
- [FatSecret OmniAuth Gem](https://github.com/scrawlon/fatsecret-omniauth) for constructing API calls.
- [Highcharts](http://www.highcharts.com/) for javascript charts to visualize daily intake.
- [Bootstrap](http://getbootstrap.com/) for styling.

Deployed to Heroku at [nutritiontracker.herokuapp.com](http://nutritiontracker.herokuapp.com).


text:
# Citymapper ETA Clock

An Arduino project for building a WiFi-powered ETA clock, that displays the number of minutes until you're expected to arrive, when a Citymapper ETA is shared with it.

In order to share with the system, either use [HTTP Request Shortcuts](https://play.google.com/store/apps/details?id=ch.rmy.android.http_shortcuts) for Android with the supplied `settings.json` (alter the URL to match your own), or use workflow.is for iOS.

The system consists of two components:

First, an AWS setup (which could easily be ported to a Raspberry Pi if you're willing to put it on the internet). It consists of an API Gateway that triggers a lambda that then enables a cloudwatch rule to trigger itself every minute until the ETA expires or you arrive. Each minute it updates the eta into an S3 bucket that's set to serve static HTTP, from which the Arduino gets its information.

Second, an Arduino Nano Nano 33 IOT project that fetches this information and reports the current eta using a stepper motor, updating every minute.

The dial points to zero when idle, and counts down from 60 minutes otherwise.

The Arduino WiFi connection can be re/configured via BLE to save having to reprogram. The stepper motor position can also be manually reset if required.

To set up the 'server-side' component on AWS (you could of course host it yourself elsewhere if suitable, but this setup costs <$1/mo, or free during first year):

* Create a Lambda function with a python 3 runtime
* Create a Bucket to store the data, and enable static website hosting
* Create a Cloudwatch event rule to trigger the lambda every minute (disabled to begin with!)
* Make sure the lambda has permissions to write to the bucket
* Create an API Gateway endpoint that backs onto the lambda
* Update the Arduino project with the S3 URL to get its angle
* Use [HTTP Request Shortcuts](https://play.google.com/store/apps/details?id=ch.rmy.android.http_shortcuts) on Android (or workflow.is on iOS - untested) to set up a Share menu option that calls the API Gateway webhook

The Arduino project requires the following:

* An Arduino Nano 333 IOT
* A 28BYJ-48 Stepper moter and ULN2003 driver board
* A push to break switch (to reset the stepper) + pulldown resisitor
* An LED

The Arduino operates as follows:

* At boot, it tries to connect to Wifi with stored credentials. If this fails, it enables BLE and the LED starts blinking
* When successfully connected, the LED goes solid, and the SSID and password can be set via the two available characteristics, using a BLE debug app (e.g. nRF Connect for Android)
* Once disconnected, the LED goes out, and the WiFi connection is attempted again
* Once successfully connected, the credentials are stored in Flash memory
* Every minute, the board connects to the given URL to fetch the number of steps to turn, and updates accordingly
* In order to reset the stepper position (since it has no 'memory', and the Flash memory on the board is unsuitable for many writes), hold the button down until the dial points to zero, then release, the clock will then adjust to the correct offset.

repository: fredley/citymapper-eta-clock

repo_name: fredley/citymapper-eta-clock


text:
---
id: 3831
title: Mont Pantoja
date: 2021-04-06T12:01:46+00:00
author: Laima
layout: post
guid: https://ukdataservers.com/mont-pantoja/
permalink: /04/06/mont-pantoja/
---

* some text
{: toc}

## Who is Mont Pantoja

Social media personality who rose to fame for her lip-synching and trending dance routines on her self-titled TikTok account. She has built a fanbase of more than 18 million followers on the platform. She became a member of the social collective Cheli House in July 2020.

## Prior to Popularity

One of her oldest archived TikToks was set to a sound made famous by KeshKesh.

## Random data

In March of 2020, she began publishing YouTube videos regularly. She has earned over 1.5 million subscribers on her YouTube channel. She calls her followers “chelitos.” She also has more than 6 million followers on Instagram where she shares pictures of her lifestyle, posing in stylish fashion.

## Family & Everyday Life of Mont Pantoja

Her full name is Paola Montserrat Pantoja Lizárraga. She’s the cousin of famed YouTuber Juan De Dios Pantoja. She began dating Edwin Mendoza. She was previously in a relationship with fellow TikTok star Rodrigo Contreras.

## People Related With Mont Pantoja

In July 2020, she performed a lip-sync on her TikTok featuring Domelipa, set to the song “La Playa” by Myke Towers.


text:
# SunPy Sphinx Theme

This repository contains the still work in progress sphinx theme for the new
website and documentation.

To use put this in your `conf.py` file:

    from sunpy_sphinx_theme.conf import *

repository: DuyguKeskek/sunpy-sphinx-theme

repo_name: DuyguKeskek/sunpy-sphinx-theme


text:
[![Build Status](https://github.com/fred78290/kubernetes-svc-dependencies/actions/workflows/ci.yml/badge.svg)](https://github.com/Fred78290/kubernetes-svc-dependencies/actions)
[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=Fred78290_kubernetes-svc-dependencies&metric=alert_status)](https://sonarcloud.io/dashboard?id=Fred78290_kubernetes-svc-dependencies)
[![Licence](https://img.shields.io/hexpm/l/plug.svg)](https://github.com/Fred78290/kubernetes-svc-dependencies/blob/master/LICENSE)

# Kubernetes service dependencies ready checker #

when you create resources in kubernetes often yours containers failed to start because they need somes already running resources before starting. For example you deploy a php website and it must connect to a MySQL server. With kubernetes service dependencies embeded in the deployment, the container doesn't start until his all dependencies are ready

### How it work ###

kubernetes service dependencies use "initContainers" mechanism of kubernetes. You can see the sample [examples/helloworld.json](examples/helloworld.json).

This sample is helloworld waiting a ready mongodb instance before to start.

### Releases ###

* 1.13.3 (unmaintened)
    - This version is supported kubernetes v1.13.3
* 1.15.0 (unmaintened)
    - This version is supported kubernetes v1.15.0
* 1.16 (unmaintened)
    - This version is supported kubernetes v1.15
* 1.17.5 (unmaintened)
    - This version is supported kubernetes v1.17
* 1.18.2 (unmaintened)
    - This version is supported kubernetes v1.18
* 1.20.5
    - This version is supported kubernetes v1.20
* 1.21.0
    - This version is supported kubernetes v1.21

### How to use? ###

When you create kubernetes resources, just add an init container belong to your container.

```json
"spec": {
    "initContainers": [
        {
            "image": "fred78290/kubernetes-svc-dependencies:v1.20.5",
            "command": [
                "/usr/local/bin/check-dependencies"
            ],
            "args": [
                "-v",
                "--namespace=kube-public",
                "--kubeconfig=/etc/kubernetes/config",
                "--maxretry=5",
                "--sleep=15",
                "--timeout=300",
                "svc/kube-public:mongodb"
            ],
            "name": "helloworld-init",
            "volumeMounts": [
                {
                    "name": "kubeconfig",
                    "mountPath": "/etc/kubernetes/config",
                    "readOnly": true
                }
            ]
        }
    ],
    "containers": [
        ...
    ],
    "volumes": [
        {
            "name": "kubeconfig",
            "hostPath": {
                "path": "/etc/kubernetes/admin.conf",
                "type": "File"
            }
        }
    ]
}
```

### Command line arguments ###

| Name | Description |
| --- | --- |
| `-n \| --namespace` | Default namespace |
| `-k \| --kubeconfig` | Kubeconfig file  |
| `-a \| --apiserver` | apiserver host  |
| `-r \| --maxretry` | The number of retry before a dependency is considered as unready  |
| `-b \| --keeponerror` | Try always to reach the dependency else the process exit  |
| `-i \| --ignoreerror` | Ignore error  |
| `-v \| --verbose` | Verbose  |
| `-s \| --sleep` | Time interval in `time.Duration` unit  |
| `-t \| --timeout` | Time to wait before to declare service down in `time.Duration` unit  |
| `dependencies` | Enumeration of dependencies |

### Syntax to enumerate dependencies ###

The dependency is composed of 3 parts: type of kubernetes resource, namespace and resource name. The syntax is < resource >/< namespace >:< name >

| Resource | Description |Example |
| --- | --- | --- |
| `po` | Pod |`po/kube-public:mongodb-023a4` |
| `deploy` | Deployment | `deploy/kube-public:mongodb` |
| `ds` | DaemonSet | `ds/kube-public:mongodb` |
| `rs` | Replicaset | `rs/kube-public:mongodb` |
| `rc` | Replication controller | `rc/kube-public:mongodb` |
| `sts` | Statefulset | `sts/kube-public:mongodb` |
| `svc` | Service | `svc/kube-public:mongodb` |

## Build ##

To build the docker image, enter `make container`


text:
# OmsInTheAir Base 1

The primary base for OmsInTheAir helps us interact with the autonomous functions of the plane.

## Installation

Use the package manager [npm](https://www.npmjs.com/get-npm) to install the packages needed.

```bash
npm install
```

## Usage

```bash
npm start
```

## Contributing
Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests as appropriate.

## Author

👤 **Adam El Messaoudi**

* Twitter: [@omsintheair](https://twitter.com/omsintheair)
* Github: [@adamthecro](https://github.com/adamthecro)

## Show your support

Give a ⭐ if this project helped you!

## License
[MIT](https://choosealicense.com/licenses/mit/)

repository: mimissuri/omsintheair

repo_name: mimissuri/omsintheair


text:
# Documenting body and file parameters for an endpoint
Scribe can get information about your endpoint's body parameters in two ways:
- the fully-manual way (using the `@bodyParam` annotation)
- the mostly-automatic way (using FormRequests)

## The manual way: Specifying body parameters with @bodyParam
To describe body parameters for your endpoint, use the `@bodyParam` annotation on the method handling it.

The `@bodyParam` annotation takes the name of the parameter, its type, an optional "required" label, and then its description. Valid types:
- `int` / `integer`
- `string`
- `number` / `float`
- `boolean`
- `array`, `object` (see [Handling array and object parameters](#handling-array-and-object-parameters) below)
- `file` (see [Documenting File Uploads](#documenting-file-uploads) below)

By default, Scribe will generate a random value for each parameter, to be used in the example requests and response calls. If you'd like to use a specific example value, you can do so by adding `Example: your-example-here` to the end of your description.

You can also exclude a particular parameter from the generated examples by ending with `No-example` instead. This will also prevent the parameter from being sent along in response calls. The parameter will still be included in the text of the documentation.

Here's an example:

```php
/**
 * @bodyParam user_id int required The id of the user. Example: 9
 * @bodyParam room_id string The id of the room.
 * @bodyParam forever boolean Whether to ban the user forever. Example: false
 * @bodyParam another_one number This won't be added to the examples. No-example
 */
public function createPost()
{
    // ...
}
```

The body parameters will be included in the generated documentation text and example requests:

![](images/endpoint-bodyparams-1.png)

If you're using a FormRequest in your controller, you can also add the `@bodyParam` annotation there instead, and Scribe will fetch it.

```php
/**
 * @bodyParam title string The title of the post.
 * @bodyParam body string required The content of the post.
 */
class CreatePostRequest extends \Illuminate\Foundation\Http\FormRequest
{

}

// in your controller...
public function createPost(CreatePostRequest $request)
{
    // ...
}
```

### Handling array and object parameters
Sometimes you have body parameters that are arrays ir ibjects. To handle them in `@bodyparam`, Scribe follows Laravel's convention:
- For arrays: use `<name>.*`
- For objects: use `<name>.<key>`.

This means that, for an array of objects, you'd use `<name>.*.<key>`.

You can also add a "parent" description if you like, by using `@bodyParam` with the type as "object" or "array".

```php
/**
 * @bodyParam user object required The user details
 * @bodyParam user.name string required The user's name
 * @bodyParam user.age string required The user's age
 * @bodyParam friend_ids array List of the user's friends.
 * @bodyParam friend_ids.* int User's friends.
 * @bodyParam cars.*.year string The year the car was made. Example: 1997
 * @bodyParam cars.*.make string The make of the car. Example: Toyota
 */
```

![](images/endpoint-bodyparams-2.png)

## Using FormRequests
If you're using Laravel or Dingo FormRequests in your controller method, Scribe can extract information about your parameters from your validation rules. Since these rules only describe validation logic, you can also add a `bodyParameters` method where you can add a description and example for each parameter.

**Not all rules are supported.** Here are the supported rules:
- `required`
- `bool`
- `string`
- `int`
- `numeric`
- `array`
- `file`
- `timezone`
- `email`
- `url`
- `ip`
- `json`
- `date`
- `date_format`
- `image`
- `in`

Custom rules are not supported. Scribe will ignore any rules it does not support.

For each parameter in `rules()` it encounters, Scribe will:
- generate an example value that passes all the supported rules. Note that if you have rules that are not supported, the generated value might not pass them. You can get around that by specifying an example in the `bodyParameters()` method.
- generate a description that combines the supported validation rules with any description you specify in `bodyParameters()`

Here's an example:

```php
class CreatePostRequest extends FormRequest
{
    public function rules()
    {
        return [
            'content' => 'string|required|min:100',
            'title' => 'string|required|max:400',
            'author_display_name' => 'string',
            'author_homepage' => 'url',
            'author_timezone' => 'timezone',
            'author_email' => 'email|required',
            'publication_date' => 'date_format:Y-m-d',
            'category' => ['in:news,opinion,quiz', 'required'],
        ];
    }

    public function bodyParameters()
    {
        return [
            'content' => [
                'description' => 'Contents of the post',
            ],
            'title' => [
                'description' => 'The title of the post.',
                'example' => 'My First Post',
            ],
            'publication_date' => [
                'description' => 'Date to be used as the publication date.',
            ],
            'category' => [
                'description' => 'Category the post belongs to.',
            ],
        ];
    }
}
```

This gives:

![](images/endpoint-bodyparams-3.png)

## Documenting file uploads
You can document file inputs by using `@bodyParam` or FormRequest rules with a type `file`. You can add a description and example as usual.

For files, your example should be the absolute path to a file that exists on your machine. If you don't specify an example, Scribe will generate a fake file for example requests and response calls.

```php
/**
 * @bodyParam caption string The image caption
 * @bodyParam image file required The image.
 */
```

![](images/endpoint-bodyparams-4.png)

> Note: Adding a file parameter will automatically set the 'Content-Type' header in example requests and response calls to `multipart/form-data`.

repository: patrickcurl/scribe

repo_name: patrickcurl/scribe


text:
# Phone Numbers

This specification defines the schema of the data and metadata for phone numbers.

### Reference and Associated material from discussion 2019-07-19

* Implementations
    * iLib - i18n library in JavaScript
        * Phone Number Formatting, Normalization, Geolocating, and Parsing capabilities
        * https://github.com/iLib-js/iLib/blob/development/docs/tutorial/phone.md
    * libphonenumber - phone number formatting/reformatting in JS or C++
        * Google implementation
        * De-facto "standard"
        * https://github.com/google/libphonenumber

* Source materials
    * International Telecommunications Union (ITU)
        * https://www.itu.int/oth/T0202.aspx?parent=T0202
    * Wikipedia
        * https://en.wikipedia.org/wiki/Category:Telephone_numbers_by_country
        * https://en.wikipedia.org/wiki/List_of_country_calling_codes
        * https://en.wikipedia.org/wiki/National_conventions_for_writing_telephone_numbers


text:
# Taking It A Step Further

If ou are interested in taking this backup process a step further, you can easily configure the following:

1. Configure Retention Policys (to save on Amazon Costs)
2. Configure Backups for Specific Subcriptions (Vhosts)


text:
---
criterion: 8
category: Analysis and benchmarking
phase: alpha
---

#### Prompts

* What prototype testing did you do during the alpha?
* What did you plan to test?
* How did you test the prototype with end users?
* What did you learn?
* What did you change?
* What didn't you change and why?
* How many other versions of the prototype did you try?
* Why did you choose this version?

#### Evidence

Service Manager able to:

* Talk clearly about user research reports, indicating where a service required remediation
* Talk through substantial iteration in the design and content of the service during the alpha
* Explain how prototype works as end to end user journey for all user needs, including those with AD needs

gha_language: CSS


text:
# Vanitynumber

## Properties
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**id** | **str** | Unique identifier for this group. | [optional]
**phone** | **str** | The phone number. | [optional]
**status** | **str** | The status of the vanity number. Options: active, onhold, billingdecline, pendingdelete | [optional]
**minutes_used** | **float** | The amount of minutes used since last billing. | [optional]
**minutes_allowed** | **float** | The amount of minutes included with the vanity number before billed additionally. | [optional]
**voicemails_new** | **int** | The amount of voicemails that have not been downloaded. | [optional]
**voicemails_old** | **int** | The amount of voicemails that have been downloaded. | [optional]
**created_at** | **str** | When the keyword was created. | [optional]
**updated_at** | **str** | When the keyword was last updated. | [optional]

[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)


text:
OTTO WG Minutes: 12/14/2016
STATUS: Approved

## Voting Members Attending:
 - Mike Schwartz
 - Janusz Ulanowski
 - Yuriy Zabrovarnyy
 - David Walker
 - Judith Bush
 - Meg Joshi
 - Keith Hazelton

## Non-voting members
 - Andrew Hughs
 - Colin Wallis

## Special Guest:
 - Ian Young

## Notes on Conversation with Ian

MDQ arose in 2008 as a result of a conversation with Chad.
White paper introduced the concenpt of Metadata Oracle, and
interfederation by exchange of metadata, aggregation engines,
and protocol as being the way entities would acquire metadata.

What's in the MDQ protocol is scoped to that last requirement.
Simple protocol based on HTTP. Acquire metadata assocaited
with a single entity.

Oracle would be trustworthy, but providing some way of verifying
the metadata is what you're expecting.

Started out with a lot of stuff tangled into the original spec,
including a way to deal with a missing entityID--sometimes you
just have a hash of that value.

Base specification for how to acquire things.

A specific SAML case where you don't have the entityID but a transformed
value for it.

The base spec says nothing about what entity identifier is. So some use
cases have been defining an identifier for that particular query response.

In the InCommon pilot we had an "all-IDPs" identifier.

You can constrain the responses by using an identifier, especially if
you want to sign. Avoids unbounded searching...

Searching for arbitrary things is not desirbable.

Shibboleth SP has been updated to support MDQ, Shib IDPv3, SimpleSAMLphp

UK Access Federation has a pre-computation version.

The request can specify a mime type to tell the MDQ server how to
format the response. For example, XML/SAML or JSON/OTTO, or formatted
html for a browser.

The MDQ spec discussed making a query/search syntax, but decided it wasn't really needed, and not to engage in speculative development. Didn't want to
put a burden on implementers. Concerned about DOS for dynamic search
and query and signing...

Cautious of rollout of MDQ:

1) Avoid arbitrary queries
2) Implement it with completely static responder--no runtime computation
6,000 - 10,000 entities and thousands of responses.

Ian things exchanging metadata is analagous to DNS. Something like EDUGain
seems to be a fairly good reflection of a "regional hub". In terms of
a model in which large aggregates are moved around, and adapted to local
use--it's fundamental to the current conception. The participants like
EDUGain have their local clients who are asking them for metadata, and
have arrangments with them about what will be provided and the level or
trust.  And its difficult to see how that will be done without the
federation operator. A very important part of the process is that
individual registrars have different policies and procedures, and
making different decision about what to pass through to the client.

Ian made an analogy between hosts files --> DNS. It's actually more efficient.
If you have a 2GB metadata file... its slow and hard to process. Not a direct
analogy, because DNS is so small -- just an IP address, whereas the average
SAML IDP is 7k--mutliple certificates.

One reason that the per entity will co-exist is due to discovery--need
some way to represent metadata.

repository: KantaraInitiative/wg-otto

gha_language: XSLT

repo_name: KantaraInitiative/wg-otto


text:
![Intercom](Sample-ObjC/Sample-ObjC/Images.xcassets/Intercom-logo-github.imageset/Intercom_logo-github.png)

[![CocoaPods](https://img.shields.io/badge/platforms-iOS-orange.svg?maxAge=2592000)](https://cocoapods.org/pods/Intercom)
[![Languages](https://img.shields.io/badge/languages-OjbC%20%7C%20%20Swift-orange.svg?maxAge=2592000)](https://github.com/intercom/intercom-ios)
[![CocoaPods](https://img.shields.io/cocoapods/v/Intercom.svg?maxAge=2592000)](https://cocoapods.org/pods/Intercom)
[![carthage compatible](https://img.shields.io/badge/Carthage-compatible-4BC51D.svg?style=flat)](https://github.com/Carthage/Carthage)
[![Apache License](http://img.shields.io/badge/license-APACHE2-blue.svg?style=flat)](https://www.apache.org/licenses/LICENSE-2.0.html)
[![CocoaPods](https://img.shields.io/cocoapods/dt/Intercom.svg?maxAge=2592000)]()

## Installation

Intercom for iOS supports iOS 8.x and iOS 9.x.

### CocoaPods
Add the Intercom pod into your Podfile and run `pod install`.

    use_frameworks!

    target :YourTargetName do
      pod 'Intercom'
    end

###Carthage
1. Add `github "intercom/intercom-ios"` to your Cartfile.
2. Run carthage update.
3.  Drag `Intercom.framework` from `Carthage/Build/iOS` to the "Embedded Binaries" section. Make sure “Copy items if needed” is selected and click Finish.

### Manual Installation

1. [Download Intercom for iOS](https://github.com/intercom/intercom-ios/archive/master.zip) and extract the zip.
2.  Drag `Intercom.framework` to the "Embedded Binaries" section. Make sure "Copy items if needed" is selected and click Finish.
3. Create a new "Run Script Phase" in your app’s target’s "Build Phases" and paste the following snippet in the script text field:

        bash "${BUILT_PRODUCTS_DIR}/${FRAMEWORKS_FOLDER_PATH}/Intercom.framework/strip-frameworks.sh"
This step is required to work around an [App Store submission bug](http://www.openradar.me/radar?id=6409498411401216) when archiving universal binaries.

##Sample app
There is a sample app provided for both Objective-C and Swift.
To use the sample app:

1. Go to the `Sample-ObjC` or `Sample-Swift` directory and run `pod install`.
2. Open `Sample-ObjC.xcworkspace` or `Sample-Swift.xcworkspace` in Xcode.
3. Set your iOS API key and App ID at the top of `ITCAppDelegate.m` or `AppDelegate.swift`.
4. Build and run.

##Setup and Configuration

* Our [installation guide](https://docs.intercom.io/install-on-your-product-or-site/quick-install/install-intercom-on-your-ios-app) contains full setup and initialisation instructions.
* Read ["Configuring Intercom for iOS"](https://docs.intercom.io/configure-intercom-for-your-product-or-site/configure-intercom-for-mobile/configuring-intercom-for-ios).
*  Please contact us on [Intercom](https://intercom.io) with any questions you may have, we're only a message away!

## Upgrading to v3.0

Upgrading to the latest version of the iOS SDK is easy! 😉  Checkout out our [upgrade guide](https://docs.intercom.io/messenger-v3/upgrade-to-the-new-messenger-ios) for more info.

## What about events, push notifications, company and user data?

Intercom for iOS has support for all these things. For full details please read our [documentation](http://docs.intercom.io/Install-on-your-mobile-product/configuring-intercom-for-ios).

## Xcode Documentation

This documentation provides integrated help in Xcode for all public APIs in Intercom for iOS. [Download the docset](https://github.com/intercom/intercom-ios/archive/master.zip) from the repository above and Copy the content into `~/Library/Developer/Shared/Documentation/DocSets`.


text:
# easy-breaker

[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat)](http://standardjs.com/)  [![Build Status](https://travis-ci.org/delvedor/easy-breaker.svg?branch=master)](https://travis-ci.org/delvedor/easy-breaker)  [![Coverage Status](https://coveralls.io/repos/github/delvedor/easy-breaker/badge.svg?branch=master)](https://coveralls.io/github/delvedor/easy-breaker?branch=master)

A simple and low overhead [circuit breaker](https://martinfowler.com/bliki/CircuitBreaker.html) utility.

## Install
```
npm i easy-breaker
```

## Usage
Require the library and initialize it with the function you want to put under the Circuit Breaker.
```js
const EasyBreaker = require('easy-breaker')
const simpleGet = require('simple-get')

const get = EasyBreaker(simpleGet)

get('http://example.com', function (err, res) {
  if (err) throw err
  console.log(res.statusCode)
})
```

If the function times out, the error will be a `TimeoutError`.

If the threshold has been reached and the circuit is open the error will be a `CircuitOpenError`.

You can access the errors constructors with `require('easy-breaker').errors`.

You can access the state constants with `require('easy-breaker').states`.

### Options
You can pass some custom option to change the default behavior of `EasyBreaker`:
```js
const EasyBreaker = require('easy-breaker')
const simpleGet = require('simple-get')

// the following options object contains the default values
const get = EasyBreaker(simpleGet, {
  threshold: 5
  timeout: 1000 * 10
  resetTimeout: 1000 * 10
  context: null,
  maxEventListeners: 100
  promise: false
})
```

- `threshold`: is the maximum numbers of failures you accept to have before opening the circuit.
- `timeout:` is the maximum number of milliseconds you can wait before return a `TimeoutError` *(read the caveats section about how the timeout is handled)*.
- `resetTimeout`: time before the circuit will move from `open` to `half-open`
- `context`: a custom context for the function to call
- `maxEventListeners`: since this library relies on events, it can happen that you reach the maximum number of events listeners before the *memory leak* warn. To avoid that log, just set an higher number with this property.
- `promise`: if you need to handle promised API, see below.

### Promises
Promises and *async-await* are supported as well!

Just pass the option `{ promise: true }` and you are done!

*Note the if you use the promise version of the api also the function you are wrapping should return a promise.*

```js
const EasyBreaker = require('easy-breaker')
const got = require('got')

const get = EasyBreaker(got, { promise: true })

get('http://example.com')
  .then(console.log)
  .catch(console.log)
```

## Events
This circuit breaker is an event emitter, if needed you can listen to its events:
- `open`
- `half-open`
- `close`
- `result`
- `tick`

## Caveats
Run a timer for every function is pretty expensive, especially if you are running the code in a heavy load environment.

To fix this problem and get better performances, `EasyBreaker` uses an atomic clock, in other words uses an interval that emits a `tick` event every `timeout / 2` milliseconds.

Every running functions listens for that event and if the number of ticks received is higher than `3` it will return a `TimeoutError`.

## Acknowledgements
Image curtesy of [Martin Fowler](https://martinfowler.com/bliki/CircuitBreaker.html).

## License
**[MIT](https://github.com/delvedor/easy-breaker/blob/master/LICENSE)**

Copyright © 2018 Tomas Della Vedova

repository: luanfsf/easy-breaker

repo_name: luanfsf/easy-breaker


text:
# sample-profiler

Runs an external probabilistic sampling profiler over a lisp image, interprets
its output, and produces an HTML file with the profiling results in the
form of a collapsible call tree.  Each node in the tree shows the number of samples
followed by the description of the function sampled.

Currently only works in CCL on MacOS X (using the `sample` program).

## Usage

The following symbols are defined in the `sample-profiler` package:

`(start-profiling &key (seconds T) (verbose nil) (output-file "profile.html"))`

Starts profiling the current lisp image.  `seconds` can be a number to automatically stop profiling after that many seconds.  The default is `T` meaning don't stop until requested.  `output-file` specifies the default file to use for output.  The file is not actually created until `end-profiling` is called, and can be overridden at that time.  If `verbose` is true, shows output from the external profiler process.

`(end-profiling &key abort (verbose nil) output-file)`

Ends the current profiling session.  If `abort` is specified, kills the profiler process without waiting for the result, otherwise tries to terminate gracefully and process the results into the output file.  if `output-file` is specified, it overrides the value given in the call to `start-profiling`.  If `verbose` is true, shows output from the external profiler process.

`*show-foreign-address*`

If true, descriptions of foreign functions include their hex address.  The default is `NIL`.

## Known bugs and missing features

* Only recognizes functions created before `start-profiling` is called.  Functions created during the profiling session (by invoking the compiler or loading fasl files) are not recognized and show up as hex addresses in the dynamic heap.

* Doesn't work on linux. (Need something similar to MacOsX's `sample` program.)

* In addition to the count, should show percentage of total samples.

* Should be able to filter on percentage, not just count

* Should be able to specify expand to max depth

* Should combine sibling entries of the same lisp function into one entry.

* Need an option to expand-all-children for any node.

* Need an option to set root to any node (i.e. focus on a branch).

* Option to combine samples at different offsets of the same function.

* There should be an option to automatically open a browser window with the output.  In the IDE, might want to open a webview within the CCL app.

repository: Clozure/sample-profiler

repo_name: Clozure/sample-profiler


text:
---
title: Typeof Type Operator
layout: docs
permalink: /docs/handbook/2/typeof-types.html
oneline: "Step one in learning TypeScript: The basics types."
beta: true
---

## The `typeof` type operator

JavaScript already has a `typeof` operator you can use in an _expression_ context:

```ts twoslash
// Prints "string"
console.log(typeof "Hello world");
```

TypeScript adds a `typeof` operator you can use in a _type_ context to refer to the _type_ of a variable or property:

```ts twoslash
let s = "hello";
let n: typeof s;
//  ^?
```

This isn't very useful for basic types, but combined with other type operators, you can use `typeof` to conveniently express many patterns.
For an example, let's start by looking at the predefined type `ReturnType<T>`.
It takes a _function type_ and produces its return type:

```ts twoslash
type Predicate = (x: unknown) => boolean;
type K = ReturnType<Predicate>;
//   ^?
```

If we try to use `ReturnType` on a function name, we see an instructive error:

```ts twoslash
// @errors: 2749
function f() {
  return { x: 10, y: 3 };
}
type P = ReturnType<f>;
```

Remember that _values_ and _types_ aren't the same thing.
To refer to the _type_ that the _value `f`_ has, we use `typeof`:

```ts twoslash
function f() {
  return { x: 10, y: 3 };
}
type P = ReturnType<typeof f>;
//   ^?
```

### Limitations

TypeScript intentionally limits the sorts of expressions you can use `typeof` on.

Specifically, it's only legal to use `typeof` on identifiers (i.e. variable names) or their properties.
This helps avoid the confusing trap of writing code you think is executing, but isn't:

```ts twoslash
// @errors: 1005
declare const msgbox: () => boolean;
// type msgbox = any;
// ---cut---
// Meant to use =
let shouldContinue: typeof msgbox("Are you sure you want to continue?");
```

repository: zyzbroker/typescript-handbook-pdf

repo_name: zyzbroker/typescript-handbook-pdf


text:
# LSTM-HVAC
## Devoted to the use of LSTM to predict daily HVAC consumption in buildings.
## Use of the code:
### 1. Load dataset:
Store the dataset in the data directory and create a python class that inherits from the
TimeSeriesDataset class as follows:
```python
class DatasetHVAC(TimeSeriesDataset):
    def __init__(self, *args,**kwargs):
        self.dir = 'hvac_pred/data/hvac/dataHVAC.npy'
        data = np.load(self.dir, allow_pickle=True)[:, 2:].astype('float')
        super(DatasetHVAC, self).__init__(data, 4, *args, **kwargs)
        del data
```
The path to the data and the column index of the target time series to be forecasted must be specified.
The data to be loaded must be ordered in time. Additionally, variables such as the time and date can be
removed (in the previous code, the first 2 columns were removed).

### 2. Create the settings JSON file that stores the hyperparameters to be used.
The configuration file must be stored in the Settings directory. Some examples are already provided as a template.
```json
{
	"chk_file" : "mspm2_checkpoint",
	"device" : "cuda:0",
	"epochs" : 100,
	"samples" : 100000,
	"batch_size" : 100,
	"timesteps" : 60,
	"horizon" : 96,
	"output_size": 1,
	"predictor" : "MSPM2",
	"learning_rate" : 1e-3,
	"spl" : [0.8, 0.2, 0],
	"resume" : 0,
	"ann_units" : [30, 30]
}
```
The hyper-parameters have the following meaning:
- chk_file: Name of the file where the model checkpoint will be stored.
- devide: Device used to train the gpu.
- epochs: Number of epochs during training of the predictor.
- batch_size: The batch size to be used only during training. It is implemented in a way that preserves the dynamics of the models.
- timesteps: The number of past timesteps (tau) to be unrolled in the BPTT.
- horizon: Horizon of the predictions. If the predictor forecasts multiple step at once (i.e. from k+1 to k+96), then horizon refers to
the first estimation. It is combined with output_size parameter to deal with multi-step predictions.
- output_size: It determines how many predictions are performed at once at each time step. Therefore, for multi-step predictors it has to
be combined with horizon.
- predictor: RNN architecture to be trained. Although 3 LSTM based predictors are implemented, new architectures can be included by creating the
corresponding class that extends BasePredictor class. Additionally, the python dictionary in the main file must be modified as well.
- learning rate: Learning rate to be used by Adam optimizer.
- spl: indicates the proportions of the data corresponding to train, test and validation subsets respectively.
- resume: restores the training process from checkpoint. As it is also implemented as a command line argument, ignore this parameter.
- ann_units: number of LSTM units.

### 3. Run the program as follows:
- Train from zero: ```python main.py --json mspm1```
- Restore training from checkpoint: ```python main.py --json mspm1 --resume```
- Evaluate trained model (checkpoint has to be stored): ```python main.py --json mspm1 --predict```

repository: Robolabo/LSTM-HVAC

gha_language: Python

repo_name: Robolabo/LSTM-HVAC


text:
# Energy Monitor Trait

The `energy-monitor` crate provides the `EnergyMonitor` trait.

## Dependencies

None.

## Usage
Add `energy-monitor` as a dependency in `Cargo.toml`:

```toml
[dependencies.energy-monitor]
git = "https://github.com/connorimes/energy-monitor-rs.git"
```

repository: frewsxcv/energy-monitor-rs

repo_name: frewsxcv/energy-monitor-rs


text:
---
layout: page
title: Lean Prover Zulip Chat Archive
permalink: archive/113489newmembers/63641Freshvariablescausingtrouble.html
---

## [new members](index.html)
### [Fresh variables causing trouble](63641Freshvariablescausingtrouble.html)

#### [Jack Crawford (Oct 24 2018 at 06:32)](https://leanprover.zulipchat.com/#narrow/stream/113489-new%20members/topic/Fresh%20variables%20causing%20trouble/near/136386136):
I'm in a bit of a pickle right now trying to deal with one of those messy `__mlocal__fresh__1234_56789` variables.

I have the following relevant lines in my tactic state:
``M N __mlocal__fresh_9046_21051 : matrix (fin m) (fin n) α,
r₁ : row_equivalent M __mlocal__fresh_9046_21051,
r₂ : row_equivalent_step __mlocal__fresh_9046_21051 N,
H₁ : row_equivalent.apply r₁ = __mlocal__fresh_9046_21051
⊢ elementary.apply (r₂.elem) (row_equivalent.apply r₁) = N``
Tantalisingly, I would love to perform some sort of rewrite or subst or simp with `H₁` to rewrite the goal as `⊢ elementary.apply (r₂.elem) __mlocal__fresh_9046_21051 = N`, but each of these fail.
I think I could probably perform the rewrite (just via eq.trans) if I could `have` myself something of the form
`have H₂ :  elementary.apply (r₂.elem) (row_equivalent.apply r₁) =  elementary.apply (r₂.elem) __mlocal__fresh_9046_21051` (and solve this with something like `congr, from H₁`), but unfortunately I cannot do this as I cannot explicitly write down the `__mlocal__fresh_9046_21051` (of course, the numbers change every time Lean recompiles).

Is there a way I can explicitly name my fresh variable in a less transient way?

Here's the actual code that's giving me this tactic state (you can see the fresh variable comes out of my induction over `row_equivalent`, which has two constructors, of the form `nil : Π M, row_equivalent M M` and `cons : Π (r₁ : row_equivalent M N) (r₂ : row_equivalent_step N L) , row_equivalent M L`)

``@[simp] lemma row_equivalent.apply_implements : Π {M N : matrix (fin m) (fin n) α} (r : row_equivalent M N), r.apply = N
| M N (row_equivalent.nil) := by simp[row_equivalent.apply]
| M N (row_equivalent.cons r₁ r₂) := begin
  simp[row_equivalent.apply],
  have H₁, from row_equivalent.apply_implements r₁,
  -- Here is where I see the tactic state I provided above
  sorry,
end``

#### [Mario Carneiro (Oct 24 2018 at 07:42)](https://leanprover.zulipchat.com/#narrow/stream/113489-new%20members/topic/Fresh%20variables%20causing%20trouble/near/136388270):
You should use `| _ _ (@row_equivalent.cons M N L r₁ r₂)` in the pattern match

#### [Jack Crawford (Oct 24 2018 at 10:24)](https://leanprover.zulipchat.com/#narrow/stream/113489-new%20members/topic/Fresh%20variables%20causing%20trouble/near/136394125):
Ah yes, I don't know why I didn't think of this myself -- silly question!
Thanks @Mario!


text:
# Sharding-Sphere Proposal

## Abstract

Sharding-Sphere is an ecosystem of transparent distributed database middleware, focusing on data sharding, distributed transaction and database orchestration.
It provides maximum compatibility for applications through Sharding-JDBC (a driver to implement JDBC) or Sharding-Proxy (a proxy to implement database protocol).

## Proposal

With a large number of end users, Sharding-Sphere has a fairly huge community in China.
It is also widely adopted by many [companies and organizations](http://shardingsphere.io/community/en/company/) as a solution to process their massive amounts of data.

We believe that bringing Sharding-Sphere into Apache Software Foundation could advance development of a stronger and more diverse open source community.

Dangdang submits this proposal to donate Sharding-Sphere's source codes and all related documentations to Apache Software Foundation.
The codes are already under Apache License Version 2.0.

- Code base: <https://github.com/sharding-sphere/sharding-sphere>

- Web site: <http://shardingsphere.io/>

- Documentations: <http://shardingsphere.io/document/current/>

- Community: <http://shardingsphere.io/community/>

## Background

Relational database hardly supports such huge amounts of data any more which has increased rapidly in recent years,
but for reason of technique maturity, developers and DBAs still want to use it to persist core data.

Sharding-Sphere was open sourced on Github in 2016.
At the very beginning, Sharding-Sphere is just a JDBC driver for data sharding (name as Sharding-JDBC) at Dangdang internal framework; now it offers data sharding,
distributed transaction and database orchestration. Besides JDBC, proxy to implement MySQL database protocol is also supported at present.
Furthermore, our roadmap includes Proxy for PostgreSQL protocol, Sidecar model, data repica and elastic data scalability function as well.

Due to the extension of project, we provide proxy model and sidecar model in addition to JDBC model.
Therefore, we rename it to Sharding-Sphere by a [public vote](https://github.com/sharding-sphere/sharding-sphere/issues/788),
which refers to a sharding ecosphere with Sharding-JDBC, Sharding-Proxy and Sharding Sidecar as its three sub-projects.

Sharding-JDBC has won the [TOP 20 most popular open source projects in China 2016](http://www.oschina.net/project/top_cn_2016).

## Rationale

Relational database still plays a very important role on current application system.
The maturity of products and surrounding ecosystem,
the friendliness of its data query and developers' and DBAs' mastery of it, cannot be completely replaced with other types of database in the near future.
However, current relational database cannot support cloud native very well and it is not friendly to distributed system.

It is the ultimate goal of Sharding-Sphere, which manages the databases scattering around the system, to make user use distributed databases as simply as using a single one.

Without extra cost, Sharding-JDBC directly connects database with Java application to get the best performance.

Sharding-Proxy is deployed as a stateless server and supports MySQL protocol at present.
In the paper [What’s Really New with NewSQL?](https://db.cs.cmu.edu/papers/2016/pavlo-newsql-sigmodrec2016.pdf),
three types of NewSQL are introduced, among which Sharding-Proxy is a `Transparent Sharding Middleware`.

Sharding-Sidecar can be understood as a data panel in Service Mesh.
The interaction between the application and the database provides a mesh layer.
The concept of Database Mesh is similar to Service Mesh, and it focuses on how to connect data access applications to the database.
Database Mesh will set up a huge grid system between applications and databases.
Applications and databases need be placed in the grid system. They are all objects managed by the meshing layer.

## Current Status

### Meritocracy

Sharding-Sphere was incubated at Dangdang in 2015 and open sourced on GitHub in 2016. In 2017, JingDong recognized its value and determined to sponsor this project.
Sharding-Sphere has contributors and users from many companies; we have set up the PMC Team and Committer Team. New contributors are guided and reviewed by existed PMC members.
When they are ready, PMC will start a vote to promote him/her to become a member of PMC or Committer Team.
Contributions are always welcomed and highly valued.

### Community

Now we have set development teams for Sharding-Sphere respectively in JingDong, Dangdang and Bestpay.
Companies like Sohu and Dataman have shown great interest in Sharding-Sphere.
We hope to grow the base of contributors by inviting all those who offer contributions through The Apache Way.
Right now, we make use of github as code hosting as well as gitter for community communication.

### Core Developers

The core developers, including experienced open source developers and team leaders, have formed a group full of diversity.

## Known Risks

### Orphaned products

Three development teams from JingDong, Dangdang and CHINA TELECOM Bestpay will spare no pains to work on Sharding-Sphere in the future with contributors from the growing community.
Also, Sharding-Sphere is widely adopted in China by many [companies and organizations](http://shardingsphere.io/community/en/company/).
Thus, it is very unlikely that Sharding-Sphere becomes orphaned.

### Inexperience with Open Source

The current core developers all work for companies that have developed or contributed to many open source projects.

Liang Zhang, PMC. He is the lead of two open source projects, Sharding-Sphere and [Elastic-Job](https://github.com/elasticjob).
Also Committer of [Apache Dubbo (Incubator)](https://incubator.apache.org/projects/dubbo.html).

Sheng Wu, PMC. He is the  PPMC and committer of [Apache SkyWalking(Incubating)](https://github.com/apache/incubator-skywalking),
[Apache Zipkin(Incubating)](https://zipkin.io/) contributor, CNCF [OpenTracing](http://opentracing.io/) member.
Also contributed a lot other open source projects.

Hongtao Gao, PMC. He is the PPMC and committer of [Apache SkyWalking(Incubating)](https://github.com/apache/incubator-skywalking) too.
Also contribute a lot of features of [Elastic-Job](https://github.com/elasticjob).

Therefore, we believe we have enough experience to deal with open source.

### Homogenous Developers

The current core developers work across a variety of organizations including Jingdong, Dangdang and CHINA TELECOM Bestpay;
some individual developers are accepted as core developers of Sharding-Sphere as well.
Considering that Sohu and Dataman have shown great interest in Sharding-Sphere, we plan to encourage them to contribute and invite them as contributors to work together.

### Reliance on Salaried Developers

At present, three of the core developers are paid by their employer to contribute to Sharding-Sphere project.
It is estimated that the development of Sharding-Sphere will be continued with mainly salaried developers, and we will make efforts to attract more volunteers and grow the community.

### Relationships with Other Apache Products

An automatic prober of Sharding-Sphere is introduced into SkyWalking to send APM data, and SkyWalking also use Sharding-Sphere to persit tracing data.
Saga provided by ServiceComb is adopted by Sharding-Sphere as one of the distributed transaction processing engines.
Sharding-Sphere integrates Apache Zookeeper as one of the service registration/discovery mechanisms.

### A Excessive Fascination with the Apache Brand

We acknowledge the value and reputation that the Apache brand would bring to Sharding-Sphere.
However, our primary interest is in the excellent community provided by Apache Software Foundation, in which all the projects could gain stability for long-term development.

## Documentation

A complete set of Sharding-Sphere documentations is provided on shardingsphere.io in both English and Simplified Chinese.

- [English](http://shardingsphere.io/document/current/en/)
- [Chinese](http://shardingsphere.io/document/current/cn/)

## Initial Source

The project consists of three distinct codebases: core, example and document. The address of three existed git repositories are as follows:

-  <https://github.com/sharding-sphere/sharding-sphere>
-  <https://github.com/sharding-sphere/sharding-sphere-example>
-  <https://github.com/sharding-sphere/sharding-sphere-doc>

## Source and Intellectual Property Submission Plan

The codes are currently under Apache License Version 2.0 and have been verified to have no intellectual property or license issues before being released to open source by Dangdang in 2016.
Dangdang will provide SGA and all committers will sign ICLA after Sharding-Sphere is accepted into the Incubator.

## External Dependencies

As all dependencies are managed using Apache Maven, none of the external libraries need to be packaged in a source distribution.
All dependencies have Apache compatible licenses except MySQL (GPL-2.0).

We will remove MySQL dependencies in future. MySQL JDBC driver is adopted by Sharding-Proxy to connect MySQL now;
We will use SPI to load JDBC driver, so MySQL JDBC driver is no longer provided on Sharding-Sphere.

| *Dependency*                         | *License*       | *Comments*                                                     |
| ------------------------------------ | --------------- | -------------------------------------------------------------- |
| Guava                                | Apache-2.0      |                                                                |
| Guava Retrying                       | Apache-2.0      |                                                                |
| commons-codec                        | Apache-2.0      |                                                                |
| commons-pool                         | Apache-2.0      |                                                                |
| commons-dbcp                         | Apache-2.0      |                                                                |
| netty                                | Apache-2.0      |                                                                |
| curator                              | Apache-2.0      |                                                                |
| grpc                                 | Apache-2.0      |                                                                |
| protobuf                             | BSD 3-clause    |                                                                |
| lombok                               | MIT             |                                                                |
| groovy                               | Apache-2.0      |                                                                |
| snakeyaml                            | Apache-2.0      |                                                                |
| spring-context-support               | Apache-2.0      |                                                                |
| spring-context-test                  | Apache-2.0      |                                                                |
| spring-boot-starter                  | Apache-2.0      |                                                                |
| spring-boot-configuration-processor  | Apache-2.0      |                                                                |
| spring-boot-starter-test             | Apache-2.0      |                                                                |
| slf4j                                | MIT             |                                                                |
| logback                              | EPL-1.0         |                                                                |
| junit                                | EPL-1.0         |                                                                |
| hamcrest                             | BSD 3-clause    |                                                                |
| mockito                              | MIT             |                                                                |
| h2                                   | MPL-2.0/EPL-1.0 |                                                                |
| mysql                                | GPL-2.0         | Will remove before first apache release, use SPI instead of it |
| postgresql                           | BSD             |                                                                |
| mssql-jdbc                           | MIT             |                                                                |
| HikariCP                             | Apache-2.0      |                                                                |
| ANTLR                                | BSD             |                                                                |
| OpenTracing                          | BSD             |                                                                |

## Required Resources

### Git Repositories

-  <https://github.com/sharding-sphere/sharding-sphere.git>
-  <https://github.com/sharding-sphere/sharding-sphere-example.git>
-  <https://github.com/sharding-sphere/sharding-sphere-doc.git>

### Issue Tracking

The community would like to continue using GitHub Issues.

### Continuous Integration tool

Travis

### Mailing Lists

- Sharding-Sphere-dev: for development discussions
- Sharding-Sphere-private: for PPMC discussions
- Sharding-Sphere-notifications: for users notifications

## Initial Committers

- 张亮, Liang Zhang, [zhangliang<EMAIL_ADDRESS>- 曹昊, Hao Cao,
- 吴晟, Sheng Wu, [wusheng<EMAIL_ADDRESS>- 高洪涛, Hongtao Gao, [hanahmily<EMAIL_ADDRESS>- 张永伦, Yonglun Zhang
- 潘娟, Juan Pan
- 赵俊, Jun Zhao
- 岳令, Ling Yue
- 马晓光, Xiaoguang Ma
- 陈清阳, QingYang Chen

## Affiliations

- JD: Liang Zhang, Yonglun Zhang, Juan Pan, Jun Zhao
- Dangdang: Hao Cao, Ling Yue
- CHINA TELECOM Bestpay: QingYang Chen
- Individuals: Sheng Wu, Hongtao Gao, Xiaoguang Ma

## Sponsors

### Champion

- Roman Shaposhnik (rvs at apache dot org)

### Mentors

- Craig L Russell (clr at apache dot org)
- Benjamin Hindman (benh at apache dot org)
- Willem Ning Jiang (ningjiang at apache dot org)

### Informal Mentors

- Von Gosling (vongosling at apache dot org)

### Sponsoring Entity

We are expecting the Apache Incubator could sponsor this project.

repository: slievrly/sharding-sphere-doc

repo_name: slievrly/sharding-sphere-doc


text:
# Aftermath

To be fleshed out, but the following points are at least relevant:

* transfer bugzilla issues to github issues (only open ones, or old ones too?)
    * see [this project](https://github.com/orgs/giellalt/projects/4)
* transfer more to github:
    - dictionaries - repo prefix `dict-`
    - corpora - repo prefix `corpus-`
    - `tools/`   - in the [divvun](https://github.com/divvun/) org?
    - `techdoc/` - as `site-giellalt.uit.no`, to be published on `giellalt.uit.no`
    - `priv/`    -
    - `art/`     -
    - …
* possibly transfer other stuff to github:
    * tools
    * techdoc (`site-giellalt`?)
    * the other sites, repo prefix `site-`?
    * make the site build and publish on push/commit using github actions

After moving stuff to github, there might be a need to clean and remove files from the history.
For that the [BFG Repo-Cleaner](https://rtyley.github.io/bfg-repo-cleaner/) is a great tool.

## DONE tasks

* set up branches according to git-flow and our needs
    * partially DONE, to be further evaluated
* set up CI for the various integration branches
    * partially DONE, ongoing work
* make sure everything is working also for svn users
    * DONE (at least svn ignore, everything else works as before)
* define production languages - DONE


text:
# EdgeAuth-Token-Golang: Akamai Edge Authorization Token for Golang

EdgeAuth-Token-Golang is Akamai Edge Authorization Token in the HTTP Cookie, Query String and Header for a client.
You can configure it in the Property Manager at https://control.akamai.com.
It's the behaviors which is Auth Token 2.0 Verification and Segmented Media Protection.

EdgeAuth-Token-Golang supports for Golang 1.x

## Installation

To install Akamai Edge Authorization Token with dep:

```Shell
$ dep ensure -add github.com/mobilerider/EdgeAuth-Token-Golang
```

## Examples
#### ACL (Access Control List) parameter option

```Golang
package main

import "github.com/mobilerider/EdgeAuth-Token-Golang/edgeauth"

func main {
    acl := "/s/c/m/f/5/9/2/f5929e909d4/*"
    key := "52a152a152a152a152a152a152a1"

    config := &edgeauth.Config{
		Algo:           crypto.SHA256,
		Key:            sampleKey,
		DurationWindow: 300 * time.Second,
	}

	client := edgeauth.NewClient(config)

    token, err := client.GenerateToken(acl, false)

    if err != nil {
		// Handle error
    }

    // Use generated token

    // token would be in the form of:
    // exp=1562609231~acl=/s/c/m/f/5/9/2/f5929e909d4/*~hmac=7a6bd5d5abdad74bda765b4da67b7ad54b6a4d6ba54d67b4ad76b4

    // You will probably use that token as a value of a cookie
    // or query string parameter, the name of the parameter is
    // configured via PM
}

```
* ACL can use the wildcard(\*, ?) in the path.
* Don't use '!' in your path because it's ACL Delimiter
* Use 'escapeEarly=false' as default setting but it doesn't matter turning on/off 'Escape token input' option in the Property Manager

## Usage

#### EdgeAuth Config Class

```Golang
type Config struct {
	Algo           crypto.Hash
	Key            string
	Salt           string
	FieldDelimiter string
	ACLDelimiter   string
	StartTime      time.Time
	EndTime        time.Time
	DurationWindow time.Duration
	IP             string
	SessionID      string
	Payload        string
	Verbose        bool
}
```

| Parameter | Description |
|-----------|-------------|
| Key | Secret required to generate the token. It must be hexadecimal digit string with even-length. |
| Algo  | Algorithm to use to generate the token. ('sha1', 'sha256', or 'md5') [ Default: 'sha256' ] |
| Salt | Additional data validated by the token but NOT included in the token body. (It will be deprecated) |
| StartTime | What is the start time? (Use string 'now' for the current time) |
| EndTime | When does this token expire? endTime overrides windowSeconds |
| DurationWindow | How long is this token valid for? |
| FieldDelimiter | Character used to delimit token body fields. [ Default: ~ ] |
| AclDelimiter | Character used to delimit acl. [ Default: ! ] |
| EscapeEarly | Not implemented yet. |
| Verbose | Not implemented yet. |

#### EdgeAuth's Method

```Golang
client.GenerateToken(value, isUrl) {}
```

| Parameter | Description |
|-----------|-------------|
| value | Single URL path or Access Control List (String) |
| isUrl | Wether passed value is a url or not (Boolean) |

## Others

If you use the **Segmented Media Protection** behavior in AMD(Adaptive Media Delivery) Product, **tokenName(options.tokenName)** should be '**hdnts**'.

### TODOs

1. Implement EscapeEarly option
2. Implement Verbose option

### Inspired in [https://github.com/akamai/EdgeAuth-Token-Node](https://github.com/akamai/EdgeAuth-Token-Node)

### Important!!: This is NOT an official library from Akamai Technologies.

repository: alf-null/EdgeAuth-Token-Golang

repo_name: alf-null/EdgeAuth-Token-Golang


text:
# Sayonara, config

> A zero-config toolkit for JavaScript and TypeScript projects.

Currently this toolkit includes:

- Project initialization (`npm init`, `git init`, `.editorconfig`, etc.)
- Linting via ESLint+Prettier
- Auto formatting via Prettier
- Jest as a test runner
- TypeScript support
- JSDoc support

## Usage

**Sayonara, config** has multiple sets of configuration suitable for different types of project.

- `node-app` - Node.js app
- `node-app-ts` - TypeScript Node.js app
- `node-library` - Node.js library
- `browser-library` - a library meant to be used on the client
- `universal-library` - a library meant to be used on both the client and the server
- `npm-package` - prepare project for publish on NPM
- `ts-ready` - a typechecked JS library with index.d.ts built
- `preact-app-ts` - a TypeScript Preact App

Multiple sets are allowed.

Just run in the project directory:

```
npx @alex7kom/sayonara-config node-library npm-package
```

It will install all the needed dependencies and project boilerplate.
It will also remember installed sets so the next time you upgrade **Sayonara, config** you'll just need to run:

```
sayonara-config
```

## Usage

Commands exposed via NPM scripts:

- `lint` - lint `*.js` and `*.ts` files in `/src` directory
- `pretty` - pretty `*.js` and `*.ts` files in `/src`
- `test` - run Jest on `*.test.js(x)` and `*.test.ts(x)` files in `/src`
- `build` - run build tools where applicable

## License

MIT


text:
Pinfinity dot co
================

The source code for [www.pinfinity.co](http://www.pinfinity.co), the website
for Pinfinity books.

Created at Statamic version 1.4.2 found in `_app/statamic/statamic.php`.

Copyright and License
---------------------
Copyright: (c) 2013 by Pinfinity Consulting LLC (http://www.pinfinity.co)

Unless otherwise indicated, all source code is licensed under the MIT license. See LICENSE for details.


text:
# OpenNBT
A Java library for reading and writing NBT files as specified [here](http://minecraft.gamepedia.com/NBT_format). In addition to the base data types supported by the NBT format, OpenNBT allows for new data types to be supported, and comes pre packaged with support for other data types. If you are planning to use OpenNBT in a project that is not related to Minecraft, I would recommend [Extremely Simple Storage](https://github.com/darkhax/Extremely-Simple-Storage). Extremely Simple Storage offers similar functionality to OpenNBT but is not associated Minecraft and is not tag based.

## NOTICE
I no longer have a need for this project, so it has been discontinued. All files can be found on the [new maven](http://maven.epoxide.xyz/net/darkhax/opennbt/OpenNBT/). If you are looking for an alternative storage option that is just as simple, check out [Extremely Simple Storage](https://github.com/darkhax/Extremely-Simple-Storage) which offers the same functionality as OpenNBT. Extremely Simple Storage has faster read/write times, greater flexability and lighter weight than OpenNBT. It is also completely unassociated with Minecraft.

## Source Code
The latest source code can be found here on [GitHub](https://github.com/darkhax/OpenNBT). If you are using Git, you can use the following command to clone the project: `git clone git:github.com/darkhax/OpenNBT.git`

## Building from Source
This project can be built using the Gradle Wrapper included in the project. When the `gradlew build` command is executed, a compiled JAR will be created in `~/build/libs`. Sources and Javadocs will also be generated in the same directory. Alternatively the latest builds of OpenNBT along with Sources and Javadocs can be found [here](http://maven.rubbix.net/net/darkhax/opennbt/OpenNBT)

## Contributing
This project is open to contributions from other members of the community. If you would like to contribute towards this project you can open an issue, or create a new pull request. If you create a new pull request, please be sure to read the project [guidelines and coding standards](https://github.com/darkhax/OpenNBT/blob/master/CONTRIBUTING.md).

## Quick Start
OpenNBT is very easy to start using. The below is an example of how to read and write an NBT file using OpenNBT.
```
  // Creates a new CompoundTag with various data stored.
  CompoundTag tag = new CompoundTag("TestTag");
  tag.setInt("TestInteger", 1337);
  tag.setString("TestString", "Hello World!");
  tag.setIntArray("TestIntegerArray", new int[] { 200, 200, 208, 208, 203, 205, 203, 205, 48, 30 });

  // Writes the tag to a new file called NBTExample.nbt. Any extension can be used.
  NBTHelper.writeFile(tag, "NBTExample.nbt");

  // Reads the NBT data from the NBTExample.nbt file.
  tag = NBTHelper.readFile("NBTExample.nbt");
```

## Legal Information
OpenNBT is licensed under the [MIT license](https://opensource.org/licenses/mit-license.html). Please see the `LICENSE.txt` for more details.

## Credits
* [Steveice10](https://github.com/Steveice10) - Original author of OpenNBT.
* [Darkhax](https://github.com/darkhax) - Maintainer of this specific fork of OpenNBT.
* [Notch](http://notch.net) - Designer of the original NBT specification.
* [Lclc98](https://github.com/lclc98) - Maintainer of build system and gradle setup.