text:
[![Build Status](https://travis-ci.org/traviskaufman/cycloneJS.png)](https://travis-ci.org/traviskaufman/cycloneJS)

Cyclone is an attempt to implement an adaptation of the HTML5 [Structured
Cloning
Algorithm](http://www.w3.org/TR/html5/infrastructure.html#safe-passing-of-structured-data).

It is meant to be:

* Synchronous
* Agnostic to the JS environment (doesn't rely on `postMessage()`,
  `replaceState()`, etc), and therefore agnostic to types such as `File`,
  `Blob`, etc (which also allows it to be synchronous in the first place).
* Serve the majority of use cases out of the box, but also
  provide a mechanism to be extensible.
* Able to copy functions (including function objects) by reference.
  This is the only property that's copied by reference.
  See above about serving the *majority* of use cases.

It can handle objects containing:

* Primitives
* `null`
* `undefined`
* Number objects
* String objects
* Boolean objects
* Date objects
* RegExp objects
* Array objects
* TypedArray and ArrayBuffer object
* Object (or "plain") objects
* In most cases, Objects instantiated with the use of a custom constructor (e.g. `function Foo() { this.bar = 'baz' }; var cloneable = new Foo();`)
* Cyclic references to itself, including nested cyclic references
* Cyclic references to objects within itself, including nested cyclic references to those objects
* Non-enumerable properties, or properties with custom descriptors
  (disabled by default: see options)
* Accessor properties (disabled by default: see options)

## Usage
This module exposes a single object, `CY`, into the global scope when used within browsers. A client can then use
this module's `clone` method to perform clone operations.

```javascript
  var o = {
    date: new Date(),
    number: Math.random()
  };
  o.self = o;
  o.tricky = { self: o };

  var c = CY.clone(o);

  c === o; // false
  c.date === o.date; // false

  +(c.date) === +(o.date); // true
  c.number === o.number;  // true
  c.self === c;  // true
  c.tricky.self === c;  // true
```

Note that cycloneJS also supports AMD loading as well as use within nodeJS/CJS environments, so with node you could do something like
```javascript
var CY = require('cyclonejs');
// Do some CY.clone()-ing
```

### Cloning options
`CY.clone` takes an options hash as a second argument, which accepts the following parameters:
* `allowFunctions`: (default: `false`) If set to true, `CY.clone` will simply pass functions through to the copied object, instead of throwing an error saying it can't clone a function.

```javascript
var fnObject = {
  f: function() {}
};
var copy = CY.clone(fnObject, {
  allowFunctions: true
});
console.log(copy.f === fnObject.f) // true
```
* `suppressErrors`: (default: `false`) If set to true, `CY.clone` will return `null` instead of throwing an Error if it comes across an object it doesn't know how to clone. If you need `CY.clone` to be extremely forgiving, this is the option for you.

```javascript
var mixedBag = {
  htmlElement: document.createElement('div'),
  ctx: document.getElementsByTagName('canvas')[0].getContext('2d')
};
var result = CY.clone(mixedBag, {
  suppressErrors: true
});
console.log(result); // null
```

* `preserveDescriptors`: (default: `false`) In order to be more predictable out-of-the-box with how the Structured Cloning Algorithm
  normally behaves, this module by default does *not* preserve property descriptors/accessor methods when cloning. However, this functionality
  can be useful when one is concerned with preserving every single aspect of the original object. If this is the case, set this property to
  `true` and CY.clone() will copy the property to the new object with the descriptors intact. _NOTE_: Accessor methods will be simply passed through, *not* truly
  copied, so mutating a property on the copied object will cause the same side effects as performing the same operation on the original. If you're concerned about
  high-integrity code, this option is for you.

```javascript
var APlus = CY.clone(Array.prototype, {
  preserveDescriptors: true,
  allowFunctions: true
});

var enum = Object.create(APlus);
enum.push(1, 2, 3, 4, 5);
console.log(Object.keys(enum)); // ['0', '1', '2', '3', '4']
```

### Extending `CY.clone()`'s functionality with `defineCloneProcedure`

Because cyclone is built to be environment-agnostic, it is incapable of handling certain cloneable host objects, such as DOM elements, out-of-the-box. However, that doesn't mean that these objects themselves aren't cloneable! For example, most DOM elements can be cloned using `cloneNode()`. Cyclone comes with a method called `defineCloneProcedure` that allows you to add in your own cloning methods for host objects, or other objects, that can't be handled in a standard way by `CY.clone`. Here's how you can add support for cloning DOM nodes using `CY.clone`:

```javascript
var elementTagRE = /^HTML\w*Element$/;
CY.defineCloneProcedure({
  detect: function(obj) {
    var klass = Object.prototype.toString.call(obj).slice(8, -1);
    return elementTagRE.test(klass) && typeof obj.cloneNode === 'function';
  },
  copy: function(el) {
    return el.cloneNode()
  }
});

var orig = document.createElement('div');
var clone = CY.clone(orig);
console.log(clone !== orig); // True
```

Here's another example of how to handle most jQuery objects:

```javascript
CY.defineCloneProcedure({
  detect: function(obj) {
    return 'jquery' in obj;
  },
  copy: function($el) {
    return $el.clone();
  }
});

CY.clone($('#main')); // Returns a cloned jQuery object.
```

`defineCloneProcedure` takes an object that _must_ contain two properties `detect` and `copy`.

`detect` should be a function that takes an object and returns `true` if and only if `obj` is of the type that you want to define your custom cloning procedure for. In the above example, `detect` ensures that the `[[Class]]` of `obj` is specified as some kind of HTML Element, and that it has a function called `cloneNode`.

`copy` should be a function that takes an object and returns a copy of that object. You are responsible for providing the procedure used to copy the object. In the case of an HTML Element, we simply call its `cloneNode` method.

`defineCloneProcedure` will return `true` if the cloning procedure is successfully defined, and `false` otherwise. Note that `defineCloneProcedure` gives priority to procedures that were defined most recently. That means if you define two cloning procedures whose `detect` functions both return true for a given type of object, the latter's `copy` function will be used.

You can erase all custom cloning procedures defined by calling `CY.clearCustomCloneProcedures()`.

## License
The MIT License (MIT)

Copyright (c) 2016 Travis Kaufman

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.

repository: traviskaufman/cycloneJS

repo_name: traviskaufman/cycloneJS


text:
# el
Lightweight utility for shorthand easy creation and modification of collections of DOM elements.

![GitHub](https://img.shields.io/github/license/NetworkMonk/el.svg)
![npm<EMAIL_ADDRESS>![npm](https://img.shields.io/badge/minified%20size-5.87%20kB-blue.svg)
![GitHub code size in bytes](https://img.shields.io/github/languages/code-size/NetworkMonk/el.svg)
<EMAIL_ADDRESS>

## Installation
You can simply include the el.min.js in your project to give you access to el

### Usage

You can use el to create nested DOM elements easily
```
el('<div></div>').append([
    el('<p></p>').text('P node here),
    'Some text node here',
]);
```

You can use el to apply css styles to elements inline
```
el('.my-class').css('color', '#444').css('fontSize', '1.5rem');
```

One of the most exciting features of el, is that you can use it to setup and trigger PURE CSS transitions on elements dynamically.
```
el('.my-class').ani({opacity: 0}, 500, callback)
```
Will fade an element (or group of elements) to 0 opacity over 500ms, after the transition is completed the callback is callback.
.stop() can be called to stop a transition at any time, elements will retain current mid transition properties.

No per frame javascript is called during transition, this should be very lightweight.

Set attribute values inline to multiple elements
```
el('.input-fields).attr('disabled', 'disabled');
```

el can accept jquery objects
```
el($('.input-fields')).css('color', '#444');
```

You can add events to elements in bulk
```
el('.class-selector').addEvent('click', function() {
    // Do something
});
```

### Developing

You will need an up to date install of Node JS and NPM set up.

Download or fork the source, run this command to install all dependencies for building from source.
```
npm install
```

## Building
Gulp is used to build the minified JS file, use the command gulp build to create, this will create the build in the dist folder.

Run the following command to build minified files from source
```
gulp build
```

license: MIT

repository: NetworkMonk/el

branch_name: refs/heads/master

extension: md

gha_language: JavaScript

gha_license_id: MIT

license_type: permissive

repo_name: NetworkMonk/el


text:
# DbConnector
A performance-driven and ADO.NET data provider-agnostic ORM library for .NET

>:thumbsup:Tip
Please visit [https://www.savantbuffer.com](https://www.savantbuffer.com) for the complete documentation!

## Introduction

#### What is a DbConnector?

DbConnector is a performance-driven and ADO.NET data provider-agnostic ORM library for .NET developed for individuals who strive to deliver high-quality software solutions. [Object-Relational Mapping](https://en.wikipedia.org/wiki/Object-relational_mapping) (ORM) is a technique that lets you query and manipulate data from a database using an object-oriented paradigm. This highly efficient library helps with the task of projecting/mapping data from any database, with the support of any third party data provider, into .NET objects and is comparable to the use of raw [ADO.NET](https://en.wikipedia.org/wiki/ADO.NET) data reader implementations.

#### Why use SavantBuffer's DbConnector?

The purpose of this library is not to replace the [Entity Framework](https://en.wikipedia.org/wiki/Entity_Framework) since it can be very useful in certain scenarios.   It's for those who prefer to write SQL queries with optimal performance in mind. Some might say writing plain-text SQL queries is easier to understand and debug than using [LINQ](https://en.wikipedia.org/wiki/Language_Integrated_Query) or .NET’s query syntax. Maybe someone in your team tends to lean towards a "stored procedure only" architecture? You might also be migrating your old [Data Access Layer](https://en.wikipedia.org/wiki/Data_access_layer) code into a more “modern” framework (e.g. .NET MVC). If you can relate to one of the mentioned, you’ll be happy to use this library. This documentation will further serve as guidance while providing examples on how to tackle these situations and more.

#### How fast is DbConnector?

It's extremely fast and memory efficient! Check out the [Performance](https://www.savantbuffer.com/DbConnector/index.html#section-6_) section for more details.

## Requirements

Before we start, this documentation assumes you have knowledge on the following:

* C# 6.0 or later (other .NET languages are supported but examples will not be provided in this documentation)
* .NET Framework 4.5 or later (or .NET Core 1.0 or later)
* SQL
* Visual Studio 2017 or later
* [NuGet](https://www.nuget.org/) packages
* One or more ADO.NET data-providers (e.g. [SqlClient](https://docs.microsoft.com/en-us/dotnet/framework/data/adonet/data-providers), [Npgsql](http://www.npgsql.org/), etc.)

These topics are important for you to know since this library was developed leveraging the latest built-in .NET features. To name a few, some of these features are lambda delegates, the task-based async model, and value tuples.

## Installation

DbConnector is installed via Visual Studio's NuGet package manager: [https://www.nuget.org/packages/SavantBuffer.DbConnector ](https://www.nuget.org/packages/SavantBuffer.DbConnector)

```ini
PM> Install-Package SavantBuffer.DbConnector
```

>:warning:Warning
[.NET Standard 2.0](https://learn.microsoft.com/en-us/dotnet/standard/net-standard?tabs=net-standard-2-0) and its implementations are only supported.

## Getting Started

#### DbConnector Instance

Once you've downloaded and/or included the package into your .NET project, you have to reference the DbConnector and your preferred ADO.NET data provider namespaces in your code:

```csharp
using DbConnector.Core;
using System.Data.SqlClient; //Using SqlClient in this example.
```
Now, we can create an instance of the DbConnector using the targeted [DbConnection](https://docs.microsoft.com/en-us/dotnet/api/system.data.common.dbconnection?view=netframework-4.8) type:

```csharp
//Note: You can use any type of data provider adapter that implements a DbConnection.
//E.g. PostgreSQL, Oracle, MySql, SQL Server

//Example using SQL Server connection
DbConnector<SqlConnection> _dbConnector = new DbConnector<SqlConnection>("connection string goes here");
```
>:thumbsup:Tip
DbConnector instances should be used as a singleton for optimal performance.

#### Main Functions

There are multiple functions available depending on your goals. The ones for reading data start with the word “Read” and “Non” for non-queries. For a better understanding, the [IDbCommand Interface](https://docs.microsoft.com/en-us/dotnet/api/system.data.idbcommand?view=netframework-4.8) method naming convention was followed for all the functions. This was decided in order to assist in the migration of raw data provider code into DbConnector’s design pattern.

##### The following are the main generic functions:

* Read
* [ReadAsAsyncEnumerable (v1.6.0)](https://www.savantbuffer.com/DbConnector/index.html#item-3-9_)
* ReadFirst
* ReadFirstOrDefault
* ReadSingle
* ReadSingleOrDefault
* ReadToList
* ReadToDataTable
* ReadToDataSet
* ReadToKeyValuePairs
* ReadToDictionaries
* ReadToListOfKeyValuePairs
* ReadToListOfDictionaries
* NonQuery
* NonQueries
* Scalar
* Build

#### Basic Example

Let’s say we have an “Employee” class serving as a container for the data we want to fetch from the database. The following function example shows how to synchronously load data from a database entity called “Employees” into an object of type List<Employee>:

```csharp
public List<Employee> GetAll()
{
    return _dbConnector.ReadToList<Employee>(
        onInit: (cmd) =>
        {
            cmd.CommandText = "SELECT * FROM Employees";

        }).Execute();
}

public List<Employee> GetAllSimple()
{
    //v1.1 Allows the use of simpler overloads:
    return _dbConnector.ReadToList<Employee>("SELECT * FROM Employees").Execute();
}
```

#### What happened here?

The DbConnector was used to call the **ReadToList** function with the use of an “Employee” generic type. This function is requesting an Action<IDbJobCommand> delegate to be declared which is being explicitly provided by the use of the “onInit” named parameter. Inside this delegate, the **IDbJobCommand** argument object is then used to set the text command to run against the data source.

Noticed how a property called “CommandText” was set? This is because the [IDbCommand Interface](https://docs.microsoft.com/en-us/dotnet/api/system.data.idbcommand?view=netframework-4.8) naming convention is being followed like previously mentioned.

Lastly, a function called **Execute** was called. A functional design pattern is being used and, consequently, an IDbJob object is being returned. This pattern allows for a lot of flexibility and you'll learn more in the following sections.

## More Documentation
Please visit [https://www.savantbuffer.com](https://www.savantbuffer.com) for the complete documentation!

## Examples and Tests
* [https://github.com/SavantBuffer/DbConnector/tree/master/DbConnector.Example](https://github.com/SavantBuffer/DbConnector/tree/master/DbConnector.Example)
* [https://github.com/SavantBuffer/DbConnector/tree/master/DbConnector.Tests](https://github.com/SavantBuffer/DbConnector/tree/master/DbConnector.Tests)

## Release Notes

Please see DbConnector’s [CHANGELOG](https://github.com/SavantBuffer/DbConnector/blob/master/CHANGELOG.md) for details.

#### Known-Issues

Issues can be reported via DbConnector’s [GitHub Issues](https://github.com/SavantBuffer/DbConnector/issues) feature.

#### Pending Features

New feature requests can be submited using DbConnector’s [GitHub](https://github.com/SavantBuffer/DbConnector/issues) repo.

## License

>:loudspeaker:Notice
Copyright 2019 Robert Orama
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

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

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

## Contact

>Hello,
 My name is Robert Orama and I'm the author of the DbConnector library. As a computer engineer and software enthusiast, my goal is to share knowledge by means of this project. I hope the use of DbConnector is taken into serious consideration and can help provide efficient results for any type of .NET solution.

You can reach me via email if really necessary:
[rorama@savantbuffer.com](rorama@savantbuffer.com)

[Don’t forget to donate](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=JZVZHQMVAG3HE&item_name=Donation+for+DbConnector+open-source+library+www.savantbuffer.com&currency_code=USD&source=url)

Thank you for your support!

repository: SavantBuffer/DbConnector

gha_language: C#

repo_name: SavantBuffer/DbConnector


text:
# client

## Instructions for dev mode

1. Clone repo
1. Install with `npm i`
1. Start in dev mode with `npm run dev`.
1. This will use the development package `concurrently` to run the front end and back end simultaneously. Theu run on different ports and proxied using `package.json`.
1. Add the token query string parameter to the url e.g. `https://localhost:3000/?token=10000`.
1. Connect Sollet wallet and Sign Transaction.'

## Generating a build

1. Generate a build with `npm run build`.
1. Use `npm start` to run in production mode.
1. Production mode doesn't use `concurrently` because only the server is running and it serves the production built React app from the `/build` folder.
1. Go to port 500 instead: `https://localhost:3000/?token=10000`.

branch_name: refs/heads/main


text:
# Store(REST API)

![alt text](https://i0.wp.com/blog.fossasia.org/wp-content/uploads/2017/10/Screenshot_2.png?fit=692%2C250&ssl=1)

## Configuration

First you need to install [pip](https://pip.pypa.io/en/stable/)

If you have macOS, then you can use
```bash
sudo easy_install pip
```

If you have Ubuntu, then you need to use the following commands
```bash
sudo apt-get update
sudo apt-get -y install python3-pip
```

Now you can proceed to install the necessary libraries to run our application
Create a folder with our project and a venv folder inside:
```bash
mkdir myproject
cd myproject
python3 -m venv venv
```
Activate the virtual environment
```bash
. venv/bin/activate
```
To install the libraries, you have to use requirements.txt (the virtual environment must be activated)
```bash
pip3 install -r requirements.txt
```

## Database Migration
Before running application, you have to configure Postgres and environment variables:
```bash
export SECRET_KEY='your_secret_key'
export DATABASE_URI='your db uri'
```

,the next step is
```bash
python manage.py db init
python manage.py db migrate
python manage.py db upgrade
```

## Usage
To start the service, use the following command:
```bash
python3 run.py
```

## Running Tests
```bash
python3 -m unittest tests/test.py
```

# Libraries Usage
#### Numpy
Used to calculate percentile, filling an array with zeros using numpy.zeros
#### Flask
Framework for writing current API
#### SQLAlchemy, Flask-SQLAlchemy
Used to interact with the database
#### MarshMallow, Flask-Marshmallow
Used to convert complex data types to Python data types
#### fastjsonschema
Used to validate input data. Using regular jsonschema is also possible, but then validation will be slower.
#### datetime
It was used to validate dates, that is, the DD.MM.YYYY format, to obtain utcnow (), and also to inadmissibly enter birthdays whose date is greater than the current one.
#### unittest
Used for writting tests

# Deploy (Nginx + gunicorn + Supervisor)
![alt text](https://miro.medium.com/proxy/1*nFxyDwJ2DEH1G5PMKPMj1g.png)

To deploy the application we need a host
```bash
ssh username@host
```
The next step is to install Postgres and create a user. All the necessary steps to install Postgres on Ubuntu 18.04 are described [here](https://linuxize.com/post/how-to-install-postgresql-on-ubuntu-18-04/)

Now you can start downloading files using git clone
```bash
git clone "repo"
```
After that, install the necessary tools and libraries
```bash
sudo apt install python3-pip
sudo apt install python3-venv
python3 -m venv store/venv
```
Move to the project folder
```bash
cd store
source venv/bin/activate
pip install -r requirements.txt
```

After that, you need to slightly modify the config.py file, since there is a more convenient way than using env variables
```bash
sudo touch /etc/config.json
sudo nano /etc/config.json
```
Inside we add:
```
{
    "SECRET_KEY": "your_secret_key",
    "DATABASE_URI": "your_db_uri"
}
```

```bash
sudo nano config.py
```
Make the following changes to config.py
```python
import json

with open('/etc/config.json') as config_file:
    config = json.load(config_file)

class Config:
    SECRET_KEY = config.get("SECRET_KEY")
    SQLALCHEMY_DATABASE_URI = config.get("DATABASE_URI")
    SQLALCHEMY_TRACK_MODIFICATIONS = False
```

Follow the migration steps described above
Install nginx & gunicorn
```bash
cd
sudo apt install nginx
pip install gunicorn
```
Let's dive into nginx & gunicorn configuration
```bash
sudo rm /etc/nginx/sites-enabled/default
sudo nano /etc/nginx/sites-enabled/store
```
And add the following to this file:
```
server {
    listen 8080;
    server_name <host_ip>;
    client_max_body_size 20M;

    location / {
        proxy_pass http://localhost:8000;
        include /etc/nginx/proxy_params;
        proxy_redirect off;
    }
}
```

```bash
sudo systemctl restart nginx
```

Now you need to configure supervisor:
```bash
sudo apt install supervisor
sudo nano /etc/supervisor/conf.d/store.conf
```
It is also necessary to add the following inside:
```
[program:store]
directory=/home/<user>/store
command=/home/<user>/store/venv/bin/gunicorn -w <num> run:app
user=<user>
autostart=true
autorestart=true
stopasgroup=true
killasgroup=true
```
, where num = (2 x num_cores) + 1. You can get num_cores using the command
```bash
nproc --all
```

Launch:
```bash
sudo supervisorctl reload
```
# Extra
### Postman
Used to make API requests and validation.

gha_language: Python


text:
# Spotify for Developers

## Presentation

Here you can find my Spotify for Developers Presentation Slides and Demo

### Slides

![Spotify for Developers DDD2020](Assets/spotify-for-developers-ddd2020.png)

### Demo

![Spotify for Developers Demo](Assets/spotify-for-developers-demo.png)

repository: RoguePlanetoid/SpotifyForDevelopers

repo_name: RoguePlanetoid/SpotifyForDevelopers


text:
# sara_msgs

This repository contains all custom ROS messages related to our robot SARA in order to simplify development and deployment of the software.

## Getting Started

* ```cd catkin_workspace/src```
* ```git clone```
* ```git@github.com:WalkingMachine/sara_msgs.git```
* ```cd ../```
* ```catkin_make```

### Prerequisites

* Ubuntu 16.04
* ROS Kinetic

### Messages
See the msg folder for more information about each message

* `Bodypart.msg`

* `BoundingBox2D.msg`

* `BoundingBox3D.msg`

* `BoundingBoxes2D.msg`

* `BoundingBoxes3D.msg`

* `Entity.msg`

* `Entities.msg`

* `FaceMsg.msg`

* `Faces.msg`

* `GenderAgePrediction.msg`

* `Person.msg`

* `Pose.msg`

## Contributing

Please read [CONTRIBUTING.md](https://gist.github.com/JeffCousineau/5ddad03418b09750e2a4afcb198b50e1) for details on our code of conduct, and the process for submitting pull requests to us.

## Versioning

We use [SemVer](http://semver.org/) for versioning. For the versions available, see the [tags on this repository](https://github.com/WalkingMachine/sara_msgs/tags).

## Authors

See the list of [contributors](https://github.com/walkingmachine/sara_msgs/contributors) who participated in this project.

## License

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

gha_language: CMake


text:
cesium-gwt
==========

GWT wrappers around some of the Cesium JS library.

The latest version has been upgraded to Cesium 1.0, so hopefully cesium-gwt is
now forward-compatible with future Cesium JS releases.

The project page, including "To Do's", can be found at
http://richkadel.github.io/cesium-gwt.

License
-------

Apache 2.0

(This library is based on the Apache 2.0-licensed Cesium project at
https://github.com/AnalyticalGraphicsInc/cesium .)

repository: markerikson/cesium-gwt

repo_name: markerikson/cesium-gwt


text:
---
title: Poetry, Not Math
---

You are about to embark on change.  A change in how you feel about taking care of yourself.  Everything else flows from there.

Please do not consider this to be an instruction manual. Instruction feels like math. We are not looking for math.  You will not be given formulas.  You will be offered a loose framework along with ideas that I have found to be effective.  You will be exploring and finding what works for you, with some help.  Consider this to be an invitation to reflect upon these ideas while looking for connections to your own life.  Finding connections furthers change.

These writings are meant to be read slowly and thoughtfully.  I have endeavored to embed insight into each and every sentence.  If you read a something that strikes you, pause for a moment and look inward.  Explore the idea deeply and think about what it means to you personally.  Finding your own meaning furthers change.

My hope is that this process of reflection and change will be uplifting and ongoing. My hope is that it will feel like poetry.  We are looking for poetry.

repository: SteveAtSentosa/fituprising-static-site

repo_name: SteveAtSentosa/fituprising-static-site


text:
# How to stay alive

Staying alive is pretty easy if you play this game often however there
are lots of things to look out for.

### Food and Water

Pretty easy to get, you can collect berries, kill animals and farm for
food.  To get water all you need
to do is get water SALTWATER CANT BE USED FOR DRINKING then put it into
a container like a copper pot, put it on a campfire or some burner with
the lid on then tada\! pour it into a mug and drink it.

### Wildlife

Most wildlife is peaceful like cows or bulls (you should keep cows and
bulls around to breed and for milk) however stuff like bears, when
unexpected can kill a whole faction to counter this simple get a weapon,
in 303 you should be able to make spears that take up a tile so you can
kill animals without getting scratched at all\!

### Nature

If you live in a temperate area of the map and its not overcrowded stay,
its one of the best biomes, plently of time to grow crops, lots of
water, tons of trees, its just great.  However there is always a
way, if you live in a desert go to an area where there's a water bed so
you can grow crops also try to set a base up asap, hunt wildlife. If you
are in a tundra you can use a shovel to remove snow to grow plants
however there's constant blizzards so you can't make a lot of progress.
However in both regions you can both mine, one of the most important
things.


text:
# media-libs/libdvdread

### css
Pass the `--enable-libdvdcss` option to the configure script. Link against the `libdvdcss` library to provide an ability to access and unscramble DVD disks encrypted with the CSS (Content Scramble System) - a digital rights management (DRM) and encryption system employed on many commercially produced DVD-Video discs.

This flag should be enabled if there is a need to use CSS-protected DVDs.

### static-libs
Pass the `--enable-static` option to the configure script. Build and install a statically linked version of the `libdvdread` library.

This flag should only be enabled if there is an explicit need for the static library.

license: Unlicense

repository: filakhtov/gentoo-use-docs

repo_name: filakhtov/gentoo-use-docs


text:
---
layout: project
type: project
image: images/bgame.jpg
title: 2D Breakout Game
permalink: projects/breakoutgame
# All dates must be YYYY-MM-DD format!
date: 2020-03-28
labels:
  - Vanilla JavaScript
  - HTML
  - CSS
  - Github
summary: A 2D game built with vanilla JavaScript.
---

The 2D Breakout Game is a mobile responsive web game built with vanilla JS and styled with CSS.

Visit [The Website](https://pjmantoss.github.io/2D_breakout_game/).

Github


text:
[![Build Status](https://travis-ci.org/ekristen/http-auth-parser.svg)](https://travis-ci.org/ekristen/http-auth-parser) [![Dependency Status](https://david-dm.org/ekristen/http-auth-parser.svg)](https://david-dm.org/ekristen/http-auth-parser) [![devDependency Status](https://david-dm.org/ekristen/http-auth-parser/dev-status.svg)](https://david-dm.org/ekristen/http-auth-parser#info=devDependencies)

# http-auth-parser

This little library is used to parse and put the auth header data at `req.auth`. It can currently handle `basic` and `bearer` authentication types.

This has support for JWT tokens when `bearer` auth is being used. The token value will attempt to be parsed by the JWT parser. It ONLY does decode. If you would like to verify the token it is available at `req.auth.jwt.token`.

## Auth Object

```javascript
req.auth = {
  type: 'basic|bearer',
  username: 'username',
  password: 'password',
  token: 'token',
  jwt: {
    token: 'rawjwttoken',
    claims: 'Object of Claims from Token'
  }
}
```

## Example Code

```javascript
var authparser = require('http-auth-parser')

var http = require('http');
http.createServer(function (req, res) {
  authparser(req)

  res.writeHead(200, {'Content-Type': 'text/plain'});
  res.end(JSON.stringify(req.auth, null, 4));
}).listen(8000, '<IP_ADDRESS>');
```

`curl -XGET -H 'Authorization: Bearer mytoken' http://localhost:8000`

### Example Auth Object

```json
{
    "type": "basic",
    "username": "Aladdin",
    "password": "open sesame"
}
```

repository: ekristen/http-auth-parser

repo_name: ekristen/http-auth-parser


text:
### What is a Confidence Interval?
A Confidence Interval is how much uncertainty there is with any particular statistic. It tells you how confident you can be that the results from your sample reflect what you'd expect to find from the population.

Confidence Intervals are often used with a **Margin of Error**.

*Note: **Confidence Levels** are expressed as percentages, whereas **Confidence Intervals** are your results, and are usually numbers.*

### The Confidence Interval Formula

    X  ±  Z (s/√n)

    X = the mean
    Z = the chosen Z-Value from the table
    s = the standard deviation
    n = the number of observations

### Example Equation
We want to calculate the Confidence Interval of the height of the male population.

We have sampled 40 randomly chosen men, and measured their heights.

    n = 40

### Step 1 - Determine the *mean* value of your data
Our sample produced a *mean* of 175cm

    X = 175

### Step 2 - Determine the **standard deviation** of your data
Our sample produced a **standard deviation** of 20cm

    s = 20

### Step 3 - Determine your Confidence Level
We want a Confidence Interval of 95%.  Using the below table, our Z-Value is 1.960

    Z = 1.960

####Z-Value Table

| Confidence Interval | Z-Value |
| --- | --- |
| 80% | 1.282 |
| 85% | 1.440 |
| 90% | 1.645 |
| 95% | 1.960 |
| 99% | 2.576 |
| 99.5% | 2.807 |
| 99.9% | 3.291 |

### Step 4 - Calculate the Confidence Interval

    X  ±  Z (s/√n)

    X = 175
    Z = 1.960
    s = 20
    n = 40

    175 ± 1.960(20/√40)

    Confidence Interval = 175cm ± 6.20cm

The Confidence Interval is **168.8cm** to **181.2cm**

*Note: The value AFTER the ± is the **Margin of Error** (6.20cm)*

### Functions Used in the Confidence Interval
 * Calculator
   * Multiplication
   * Division
   * Square Root

 * Stat Calculator
   * Mean
   * Standard Deviation

 [Link to Statisticshowto.com](https://www.statisticshowto.com/probability-and-statistics/confidence-interval/)

 [Back to Index](README.md)


text:
# Project Object Tracking
 - Refer this [article1](https://www.pyimagesearch.com/2018/07/30/opencv-object-tracking/) and [article2](https://www.learnopencv.com/object-tracking-using-opencv-cpp-python/) to understand well about object tracking.

     Happy Learning💖


text:
# First-Project-Three.js

First project develop using [Three.js](https://threejs.org/) lib to create a 2D image.

![Image](/image.png)


text:
## Testing Sentry  SDK against Lambda functions

##### To test Sentry SDK integration with Python lambda function, follow the below steps.

 - Create development package from the source code
 - Upload it into Lambda console
 - Refer usage for use case specific handling

## Create a development package

##### 1. Clone the git repo on your development machine

##### 2. Cloned repo contains multiple folders, each of these folder contains an example of how we can capture errors/exceptions on sentry dashboard

##### 3. Go to any folder and edit the python source file. Edit below section of the file where you replace 'dsn' with your own DSN
```python
sentry_sdk.init(
    dsn="<your DSN>",
    integrations=[AwsLambdaIntegration()]
)
```
##### 4. Install the dependencies using following command.

```html
pip install -r requirements.txt
```

##### 5. Zip the contents of the folder so that it can be uploaded to lambda
```html
$zip filename.zip *.py *.txt
```

### Uploading the Lambda function zip file from the local machine and execution.

#####  Create a Lambda function in Python by uploading the zip file created in 'creating development package' section with LambdaAdminAccess and test event configured. For more information refer to [Python Lambda function](https://docs.aws.amazon.com/lambda/latest/dg/lambda-python.htm).

## Usage

#### 1. Out of memory:

This AWS Lambda function contains code that consumes memory limit equal to set memory limit in the configuration.

##### Configuration: Set the following parameters in Lambda dashboard for Out of memory:
```html
a) Handler : out_of_memory.lambda_handler
b) Memory (MB) : 128 MB
c) Timeout : 1 min
```

#### 2. Invalid Handler error:

This Lambda function contains code that instruments Lambda invalid handler error.

##### Configuration: Set the following parameters in Lambda dashboard for Invalid handler error:
```html
a) Handler : invalid_handler.lambda_handler_changed
```

#### 3. Handled exception:

This function contains code that instruments handled exception.

##### Configuration: Set the following parameters in Lambda dashboard for Handled exception:
```html
a) Handler : handled_exception.lambda_handler
```

#### 4. Unhandled exception:

This function contains code that instruments unhandled exception.

##### Configuration: Set the following parameters in Lambda dashboard for Unhandled exception:
```html
a) Handler : unhandled_exception.lambda_handler
```

#### 5. Network error:
This function contains code that instruments the network error using different scenarios.

>**Scenario: Wrong IP address**

In this scenario, we put the wrong IP address.

##### Configuration: Set the following parameters in Lambda dashboard for wrong IP address scenario :

```html
a) Handler : network_error_wrong_address.handler
b) Timeout : 2 min 30 sec
```

>**Scenario: Wrong PORT number**

In this scenario, we put the wrong PORT number.

##### Configuration: Set the following parameters in Lambda dashboard for wrong PORT number scenario :

```html
a) Handler : network_error_wrong_port.handler
b) Timeout : 2 min 30 sec
```

#### 6. Custom tags & Context:
This function contains code that instruments the handled exception and creates custom tag & context.

##### Configuration: Set the following parameters in Lambda dashboard for Custom tags & Context:
```html
a) Handler : custom_tag_and_context.lambda_handler
b) Environment Variables :-
   Key : ENV_VAR
   Value : Test Value
```

repository: getsentry/examples

repo_name: getsentry/examples


text:
# Invocation

Structure of the abbreviated representation of an [invoke script transaction](/blockchain/transaction-type/invoke-script-transaction.md).

## Constructor

``` ride
Invocation(caller: Address, callerPublicKey: ByteVector, payment: AttachedPayment|Unit, transactionId: ByteVector, fee: Int, feeAssetId: ByteVector|Unit)
```

## Fields

|   #   | Name | Data type | Description |
| :--- | :--- | :--- | :--- |
| 1 | caller | [Address](/ride/structures/common-structures/address.md) |  The [account](/blockchain/account.md) that sent a transaction |
| 2 | callerPublicKey | [ByteVector](/ride/data-types/byte-vector.md) | Public key of an account that sent a transaction |
| 3 | payment | [AttachedPayment](/ride/structures/common-structures/attached-payment.md)|[Unit](/ride/data-types/unit.md) | Attached payment |
| 4 | transactionId | [ByteVector](/ride/data-types/byte-vector.md) | ID of a transaction |
| 5 | fee | [Int](/ride/data-types/int.md) | Transaction fee |
| 6 | feeAssetId | [ByteVector](/ride/data-types/byte-vector.md)|[Unit](/ride/data-types/unit.md) | [Token](/blockchain/token.md) of a transaction fee |


text:
---
id: 14819
title: Aki Hakala
date: 2021-04-07T15:36:34+00:00
author: Laima
layout: post
guid: https://ukdataservers.com/aki-hakala/
permalink: /04/07/aki-hakala/
---

* some text
{: toc}

## Who is Aki Hakala

Notable as the third and most well known drummer of the Finnish rock group The Rasmus, Hakala contributed to many of the band’s award-winning albums, including Dead Letters (2003) and Hide from the Sun (2005).

## Prior to Popularity

Before becoming a member of The Rasmus, he performed with the bands Killer and Kwan. He recorded Into, his Double Platinum first album with The Rasmus, in 2001.

## Random data

An occasional actor as well as a drummer, he appeared on the Finnish television series Siamin Tytot.

## Family & Everyday Life of Aki Hakala

He grew up in Espoo, Finland. His first child, a daughter, was born in the summer of 2007.

## People Related With Aki Hakala

He and vocalist Lauri Ylonen both rose to fame as members of The Rasmus.


text:
# Call for Code Global Entry - Sew Eco!

In order to limit the impact of the fashion industry on the planet, Sew Eco! is an app to show how you can repair, resell, or recycle your clothing.

## Pre-requisites
Installing Flutter: https://flutter.dev/docs/get-started/install

VSCode setup: https://flutter.dev/docs/development/tools/vs-code

## Running
### VSCode
Add the following to the Flutter settings in VSCode
![image](https://user-images.githubusercontent.com/62894097/122807764-e0636c80-d2c3-11eb-8494-d33b837501d3.png)

Select "Run --> Run without debugging"

### Command Line
```
flutter run --no-sound-null-safety
```

When asked, choose "Chrome"

## Useful Links
Creating your first flutter app: https://flutter.dev/docs/get-started/codelab

Flutter getting started links: https://flutter.dev/docs/get-started/learn-more

gha_language: Dart


text:
# FitnessApp

FitnessApp is a fitness app.

## Considerations

### About
en the enormous world of fitness and workouts, finding good workouts and good exercises for each muscle group is a universal hassle. FitnessApp not only allows finding exercises and workouts by specific muscle group, but also shows gyms nearby, random workout options, and offline stored workouts.

### Stakeholders
Users - Fitness enthusiasts

### Core Flows
Key functions :
- Searching for workouts by muscle group
- Saving workouts for offline use
- Upload workouts
- View nearby gyms on a map

The user should see a screen for each of these.

### Final Demo
Each of the functions will be demonstrated live by alternating group members

### Mobile Features
- Maps
- Device Shake

### Technical Concerns
- Have to find gym locations API

## User Stories

- [x] User is able to register using their email address
- [x] User is able to securely login using their registered information
- [x] User is able to securely log out of the application
- [x] User logins are persisted
- [x] User is able to delete their account
- [x] User is able to view a list of popular workouts
- [x] User is able to view workouts according to muscle group
- [x] User is able to like/dislike workouts
- [ ] User is able to save workouts for offline use//
- [x] User is able to create and upload workouts
- [ ] User is able to view gyms nearby on a mapview//
- [ ] User is able shake the device to view a random workout//

## Notes

## License

    Copyright [2018] [PAProducts]

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

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

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

repository: pkamojjh/FitnessApp

repo_name: pkamojjh/FitnessApp


text:
# A simple tool for determining whether FW reboot is needed

## Intro

When running a virtual machine with the [OVMF](https://github.com/tianocore/edk2)
UEFI firmware, sometimes it is needed to determine whether the guest OS
requested a firmware interface reboot. This request is made using the
`OsIndications` UEFI variable. A possible use case for that, is stopping
the guest and rebooting the host into the physical firmware interface, _e.g._
using `systemctl reboot --firmware-setup`.

## Building

A simple `make` will do.

## Usage

```sh
./fw-reboot-needed /path/to/OVMF_VARS.fd [/path/to/another/OVMF_VARS.fd ...]
```

This works while the VM is running, as well as after it was shutdown. Note
that the variable is reset before the VM enters the FW interface. If the VM
is stopped after this reset but before the boot, `fw-reboot-needed` will still
detect that FW reboot is needed - this gives a chance to act on it while the
VM is down. But after VM restart, `fw-reboot-needed` will indicate that FW
reboot is not needed, which is true, as we have already rebooted.

## License

This code is released under the standard 3-clause BSD license.

repository: blochl/Tools

repo_name: blochl/Tools


text:
---
title: "Cloudy sky"
date: 2016-12-17T15:04:10.000Z
description: The Coffee Taster’s Flavor Wheel, the official resource used by coffee tasters, has been revised for the first time this year.
image: /img/gallery-2.jpg
---

## What the updates mean to you

The SCAA updated the wheel to reflect the finer nuances needed to describe flavors more precisely. The new descriptions are more detailed and hence allow cuppers to distinguish between more flavors.

[Go to the Support Web Site](https://support.west-wind.com)

repository: jjcgibbs/Johanna-Gibbs-Webspace

repo_name: jjcgibbs/Johanna-Gibbs-Webspace


text:
---
layout: "azuredevops"
page_title: "AzureDevops: azuredevops_team_administrators"
description: |-
  Manages administrators of a team within a project in a Azure DevOps organization.
---

# azuredevops_team_administrators

Manages administrators of a team within a project in a Azure DevOps organization.

## Example Usage

```hcl
resource "azuredevops_project" "project" {
  name               = "Test Project"
  work_item_template = "Agile"
  version_control    = "Git"
  visibility         = "private"
  description        = "My first project"
}

data "azuredevops_group" "builtin_project_contributors" {
  project_id = azuredevops_project.project.id
  name       = "Contributors"
}

resource "azuredevops_team" "team" {
  project_id = azuredevops_project.project.id
  name       = "${azuredevops_project.project.name} Team 2"
}

resource "azuredevops_team_administrators" "team_administrators" {
  project_id = azuredevops_team.team.project_id
  team_id    = azuredevops_team.team.id
  mode       = "overwrite"
  administrators = [
    data.azuredevops_group.builtin_project_contributors.descriptor
  ]
}
```

## Argument Reference

The following arguments are supported:

- `project_id` - (Required) The Project ID.
- `team_id` - (Required) The ID of the Team.
- `administrators` - (Required) List of subject descriptors to define adminitrators of the team.

  > NOTE: It's possible to define team administrators both within the
  > `azuredevops_team` resource via the `administrators` block and by using the
  > `azuredevops_team_administrators` resource. However it's not possible to use
  > both methods to manage team administrators, since there'll be conflicts.
- `mode` - (Optional) The mode how the resource manages team administrators.
  - `mode == add`: the resource will ensure that all specified administrators will be part of the referenced team
  - `mode == overwrite`: the resource will replace all existing administrators with the administrators specified within the `administrators` block

## Attributes Reference

In addition to all arguments above, the following attributes are exported:

- `id` - A random ID for this resource. There is no "natural" ID, so a random one is assigned.

## Relevant Links

- [Azure DevOps Service REST API 5.1 - Teams - Update](https://docs.microsoft.com/en-us/rest/api/azure/devops/core/teams/update?view=azure-devops-rest-5.1)

## Import

The resource does not support import.

## PAT Permissions Required

- **vso.project_write**:	Grants the ability to read and update projects and teams.

repository: XenitAB/terraform-provider-azuredevops

extension: markdown

gha_language: Go

repo_name: XenitAB/terraform-provider-azuredevops


text:
MovieHub is 100% legal unlimited streaming, with no credit cards and no subscription required.\
Choose what you want to watch, when you want to watch it, with fewer ads than regular TV.\
MovieHub is the largest free streaming service featuring award-winning movies and TV series.\
There is something for everybody; from comedy to drama, kids to classics, and niche favorites such as Bollywood, Hollywood and Indian web series.

# Features:-
----------
=> Discover the most popular,the highest rated and the most rated movies\
=> Watch movie trailers and teasres\
=> Read review from other users\
=> Mark movies as favorites\
=> Search for movies\
=> Offline work\
=> Material design\
=> UesrInterface(UI) otimized for phone and tablet

# Download APK:-
--------------

https://github.com/dewaara/MovieHubApp/blob/master/MovieHub.apk

# MovieHub_DEMO:-
---------------
[![MovieHub2020.gif](https://s7.gifyu.com/images/MovieHub2020.gif)]

# Screenshots:-
-------------

# Requirements:-
--------------
-> Java 8.1\
-> Latest version of Android Studio SDK and Android Build Tools.

# Follw Me:-
----------

| PROFILE | LINKS |
| ------ | ------ |
| Google Play | https://play.google.com/store/apps/details?id=com.dewaara.gizaquiz |
| GitHub | https://github.com/dewaara |
| Linkedin | https://www.linkedin.com/in/md-halim-a28812183 |
| Website | http://mdhalim.simplesite.com/ |
| Youtube | https://www.youtube.com/channel/UCl7BXKzd8r_Lyly91aMEMqg |

# License:-
---------

MIT License

Copyright (c) 2020 Developer Md.Halim Powered by Dewaara Inc.

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:
Concurrency Control Framework (CCF)
===================================

Note: CCF is *no longer actively developed*.

What is CCF?
------------

CCF is a library to make implementing collaborative software easier. It
provides mechanisms for real-time synchronization of data structures between
clients over the Internet. CCF is implemented in the Scala programming language.

Authors and licensing
---------------------

Origins of CCF lie in the Master's thesis of Aki Saarinen [1].  Later on there
has been also many other contributors, names of which can be found in the
version history. Most notable include Karim Osman and Harri Salokorpi.

CCF is licensed under the Apache License version 2.0.

[1] "Concurrency Control in Group Editors: Case Study in a Product Backlog Tool"
    Aki Saarinen, 2009, Helsinki University of Technology
    Available from http://www.akisaarinen.fi

Setting Up Development Environment
----------------------------------

1. Clone the git repository
2. Configure JVM
3. Fetch all depencencies

  $ ./sbt update

4. Run all tests:

  $ ./sbt test

Creating Library Package
------------------------

 $ ./sbt package

This will produce the package to:

  ./ccf/target/ccf-{version}.jar

Running the Test Application
----------------------------

The test application is a very simple collaborative text-editing application,
consisting of a server that binds to a port and a client that connects to the
server using HTTP. You may start multiple instances of the client application
locally and try out how the text is updated to the other instances in real
time. Best example of the operation is of course if you can run the client in
two machines and just specify the same server address for both clients.

Running the server application:

  $ ./sbt -p app run -s    (-s can be replaced with --server)

Optional parameters for server:

  --port <port> || -p <port>

Port defaults to 9999.

Running the client application:

 $ ./sbt -p app run       (no parameters == client)

Optional parameters for client:

  --host <host> || -h <host>
  --port <port> || -p <port>

Port defaults to 9999 and host to 'localhost'.

repository: wenkangyi/ccf

repo_name: wenkangyi/ccf


text:
---
title: "Artifacts on GCS"
meta_title: "Google GCS"
meta_description: "Using Google Cloud Storage GCS buckets to organize your jobs' outputs and experiments' artifacts. Polyaxon allows users to connect to one or multiple buckets on Google Cloud Storage GCS to store job outputs and experiment artifacts."
custom_excerpt: "Google Cloud Storage is a RESTful online file storage web service for storing and accessing data on Google Cloud Platform infrastructure. The service combines the performance and scalability of Google's cloud with advanced security and sharing capabilities."
image: "../../content/images/integrations/gcs.png"
author:
  name: "Polyaxon"
  slug: "Polyaxon"
  website: "https://polyaxon.com"
  twitter: "polyaxonAI"
  github: "polyaxon"
tags:
  - artifacts
  - storage
  - gcp
featured: false
popularity: 2
visibility: public
status: published
---

You can use one or multiple buckets on Google Cloud Storage (GCS) to store logs, job outputs, and experiment artifacts.

## Create a Google cloud storage bucket

You should create a google cloud storage bucket (e.g. plx-artifacts), and you have to assign permission to the bucket.

Google cloud storage provides an easy way to download the access key as a JSON file. You should create a secret based on that JSON file.

## Create a secret on Kubernetes

You can create a secret with an env var of the content of the gcs-key.json:

 * `GC_KEYFILE_DICT` or `GOOGLE_KEYFILE_DICT`

Or you can create a secret to be mounted as a volume:

 * `kubectl create secret generic gcs-secret --from-file=gc-secret.json=path/to/gcs-key.json -n polyaxon`

## Use the secret name and secret key in your data persistence definition

You can use the default mount path `/plx-context/.gc`, Polyaxon will set the `GC_KEY_PATH` to `/plx-context/.gc/gc-secret.json` so the secret must contain --from-file=`gc-secret.json=`

```yaml
artifactsStore:
  name: gcs-artifacts
  kind: gcs
  schema:
    bucket: "gs://gcs-artifacts"
  secret:
    name: "gcs-secret"
    mountPath: /plx-context/.gc
```

You can also use a different mount path, e.g. `/etc/gcs/gc-secret.json`, in which case you need to provide an env var to tell the SDK where to look for the secret:

```bash
kubectl create configmap gc-key-path --from-literal GC_KEY_PATH="/etc/gcs/gc-secret.json" -n polyaxon
```

```yaml
artifactsStore:
  name: gcs-artifacts
  kind: gcs
  schema:
    bucket: "gs://gcs-datasets"
  secret:
    name: "gc-secret"
    mountPath: /etc/gcs
  configMap:
    name: gc-key-path
```

## Update/Install Polyaxon deployment

You can [deploy/upgrade](/docs/setup/) your Polyaxon CE or Polyaxon Agent deployment with access to the artifacts store.

repository: polyaxon/polyaxon

repo_name: polyaxon/polyaxon


text:
## Last Week's Accomplishments

> In this section, you can write about what you accomplished in the previous week.

> This past week finished implementing switching between screens.

## This Week's Plan

> In this section, you can write about what you have planned for next week.

> This week, we plan to begin pulling data to fill our screens.

## Anything Blocking?

> In this section, you can write about any blockers that you are having trouble in the project.

> We are currently searching for websites that we can use to pull data

## Notes

> This is an optional section for any sort of information that does not fall under any of the other categories.

repository: OldManZhao/rcos-status-updates

repo_name: OldManZhao/rcos-status-updates


text:
# JavaOne 2015: Cloud One

Sample project for JavaOne 2015 presentation - "Rest Conversation". Main goal is to elaborate around REST based integration patterns in the cloud solution.

## Introduction

This project represents simulation of the simplified cloud solution. The cloud architecture is oriented for JAX-RS based micro-services.

Idea is, that each micro-service is executed as a new JVM instance (or 'cluster' of the new JVM instances). Each micro-service must be based on the same cloud framework. It means that defines extension of the C1Application class. (BTW: It is just extension of the JAX-RS Application class.) The java Main (class with main(String[]) is defined by the cloud library.

Cloud management is represented by one application which provides several cloud services including configuration, monitoring and naming.

We defined this simplified cloud solution to present one specific idea: New ReST based integration patterns between application – especially in one cloud or on one environment.

## Project Structure

We named our cloud: CloudOne. You know, it is presentation for JavaOne, so …
CloudOne libraries and executable jars are named based on cloud types.

- **Cirrus** is basic shared library for all CloudOne applications
- **Cumulonimbus** is central cloud service. In this demo it does not support clustering. It must be executed ones per cloud and it must be local for all other executed applications. You know, simple.
- **Stratus** is pom which should be used as a parent for all CloudOne micro-services.
- **Nimbostratus** is C1Application and Main class for all micro-services. Provides bootstrap functionality and administration interface for the CloudOne instance. Communication interface for Cumulonimbus.

## Build

This is pure Maven2 based project. So, use ```mvn clean install```


text:
---
title: Manage Subscription
id: "manage-subscription"
---
---

You can delegate subscription administration to manage members, view the current subscription, members, and your subscription expiration date. As an owner of the subscription, you can subscribe/unsubscribe or upgrade to a particular subscription plan. As a **Teams** admin, you can delegate ownership of the subscription to a different member.

:::note
WaveMaker support team members do not count as the number of developers allowed in the subscribed plan.
:::

- You can access the **Manage Subscription** page from the administration area by clicking **Manage Subscription** from the left panel.

![Manage Subscription](/learn/assets/TeamManageSubscription.png)

- To change the owner of the subscription, click **Change Owner** — a pop-up opens.
- Select the member to be make a new subscription owner, and click **Save**.

![Change Owner](/learn/assets/TeamChangeSubscriptionOwner.png)

repository: wavemaker/docs

repo_name: wavemaker/docs


text:
# Benchmarks

This folder contains two Haskell programs that work together to simplify the
performance analysis of ghcide:

- `exe/Main.hs` - a standalone benchmark runner. Run with `stack run ghcide-bench`
- `hist/Main.hs` - a Shake script for running the benchmark suite over a set of commits.
  - Run with `stack bench` or `cabal bench`,
  - Requires a `ghcide-bench` binary in the PATH (usually provided by stack/cabal),
  - Calls `cabal` (or `stack`, configurable) internally to build the project,
  - Driven by the `config.yaml` configuration file.
    By default it compares HEAD with "master"

Further details available in the config file and the module header comments.

gha_language: Haskell


text:
EE 703 Digital Message Transmission (Autumn 2013)
-------------------------------------------------

This repository contains the LaTeX files pertaining to the Autumn 2013 edition of the EE703 course at IIT Bombay. The pdf files corresponding to these source files can be found at [this link](http://www.ee.iitb.ac.in/~sarva/EE703/Autumn2013.html)

Compiling the source files
--------------------------

* For the assignments and exams, `pdflatex file.tex` will generate the pdf as long as you have the necessary LaTeX packages installed. For example, files containing figures require `tikz` to be installed.
* For the slides, there is a `Makefile` which helps generate both handout and non-handout versions of the pdf. In the handout version, all the `\pause` commands in `beamer` are disabled.

    + For the non-handout version, simply type `make` in the `slides` subdirectory
    + For the handout version, type `make handout` in the `slides` subdirectory

* Some slide decks contain plots which requires `gnuplot` to be installed on your machine.
License
-------
This code is being released under the permissive [MIT License](http://choosealicense.com/licenses/mit/)


text:
# List of python-constraint contributors and notable users (sorted alphabetically)

- Sébastien Celles - https://github.com/scls19fr - project co-maintainer
- Aron Griffis - https://github.com/agriffis
- Matt Kindy - https://github.com/mattkindy-praetorian
- Arun Mahapatra - https://github.com/codito
- Gustavo Niemeyer - https://github.com/niemeyer/ - initial author

[Full Github contributors list](https://github.com/python-constraint/python-constraint/graphs/contributors).

and maybe more...

repository: SaverioFrancesco/python-constraint

repo_name: SaverioFrancesco/python-constraint


text:
## 2.0.6 (2016-02-15)

### Bug Fixes
* **validator:** Allow emails with address extension, e.g<EMAIL_ADDRESS>([125fe9f](https://github.com/poppinss/indicative/commit/125fe9f))

## 2.0.5 (2016-01-21)

### Bug Fixes

* **exported-tests:** removed unwanted exported tests ([16288bf](https://github.com/poppinss/indicative/commit/16288bf))

### Features

* **package:** added commitizen ([c8c319d](https://github.com/poppinss/indicative/commit/c8c319d))
* **sanitizaor:** Added extend method to add sanitization filters ([dc11f5a](https://github.com/poppinss/indicative/commit/dc11f5a))
* **sanitizations:** Added support for sanitizations ([ee33244](https://github.com/poppinss/indicative/commit/ee33244))

## 2.0.4 (2016-01-21)

### Features

* **package:** added commitizen ([c8c319d](https://github.com/poppinss/indicative/commit/c8c319d))
* **sanitizaor:** Added extend method to add sanitization filters ([dc11f5a](https://github.com/poppinss/indicative/commit/dc11f5a))
* **sanitizations:** Added support for sanitizations ([ee33244](https://github.com/poppinss/indicative/commit/ee33244))

repository: RomainForks/indicative

repo_name: RomainForks/indicative


text:
This is the first of three app examples demonstrating how a real work code can be registered and used in Agave. The app is a Python code that takes a csv file and creates a graph of the data. We detail how to create a JSON description of the code we want to run, how to create the wrapper template that Agave uses to run the code, and how to test and run the app with Agave.

You can download the full source code for this example app and client application in the Agave Samples repository in the apps/pyplot-demo/basic/pyplot-demo-basic-0.1.0 directory. If you would like to run this app in a live environment, you can register your own compute and storage systems, or use one of our developer sandbox environments.

## Basic app overview

The app we're going to be using in this example is a native Python app that creates plots and charts of CSV data. The app itself is loosely based on example programs from the matplotlib cookbook with a healthy dose of parameterization, exception handling, and logging added for usability. The app's help output is listed below.

[code lang=text]
python main.py -h
usage: pyplot-demo [-h] [--chart-type {bar,line}] [--x-label [XLABEL]]
                   [--show-x-label] [--y-label [YLABEL]] [--show-y-label]
                   [--show-legend] [--width WIDTH] [--height HEIGHT]
                   [--background-color BACKGROUND] [--output-location OUTDIR]
                   [--file-per-series] [--format {png,jpg,gif}] [-v]
                   infile

A program to plot the contents of a csv file.

positional arguments:
  infile                The dataset to plot.

optional arguments:
  -h, --help            show this help message and exit
  --chart-type {bar,line}
                        The type of chart to show.
  --x-label [XLABEL]    The x-axis label.
  --show-x-label        If specified, the x-axis label will be shown
  --y-label [YLABEL]    The y-axis label.
  --show-y-label        If specified, the y-axis label will be shown
  --show-legend         If specified, a legend will be generated for each
                        chart.
  --width WIDTH         The chart width.
  --height HEIGHT       The chart height.
  --background-color BACKGROUND
                        The css hex color of the chart background.
  --output-location OUTDIR
                        The output directory of the plotted dataset.
  --file-per-series     If specified, each chart will be saved in a separate
                        file.
  --format {png,jpg,gif}
                        The image format of the plotted dataset.
  -v, --verbose         Enable verbose output.
```

While the app itself provides quite a few options, in this basic example, we will work under the assumption that end users don't need or use the majority of the options available from the pyplot code. The app we create will focus on two options: the kind of chart they want to create, `chart-type`, and the input file they want to plot, `infile`.

As you will see, these two options will allow us to build a basic app description and highlight the major concepts of app registration. In the intermediate and advanced examples we will build on this example by exposing more of the pyplot options and demonstrating how Agave can help you with data scheduling, parameter validation, and batch processing.

### Runtime requirements

In order to run this app, the target execution system must have the following installed.

<ul>
<li>Python 2.7</li>
<li>Matplotlib</li>
</ul>

If you are following along on your local system, you will need to have these installed in order to run the wrapper script and invoke the pyplot Python code.

### Creating the app JSON description

In order to register our example app, we need to create a JSON description of it so Agave knows where it should run and how to run it. The JSON for our basic app is below.

```javascript
{
  "name": "demo-pyplot-demo-basic",
  "parallelism": "SERIAL",
  "version": "0.1.0",
  "label": "PyPlot Demo Basic",
  "shortDescription": "Basic demo plotting app",
  "longDescription": "Basic demo app to create a graph using Python",
  "deploymentPath": "apps/pyplot-demo-basic-0.1.0",
  "deploymentSystem": "demo.storage.example.com",
  "executionSystem": "demo.execute.example.com",
  "executionType": "CLI",
  "templatePath": "wrapper.sh",
  "testPath": "test/test.sh",
  "tags": [
    "demo",
    "python",
    "tutorial",
    "plotting"
  ],
  "ontology": [],
  "inputs": [{
    "id": "dataset",
    "value": {
      "default": "agave://demo.storage.example.com/inputs/pyplot/dataset.csv",
      "required": true
    },
    "details": {
      "label": "Dataset",
      "description": "The dataset to plot"
    }
  }],
  "parameters": [{
    "id": "chartType",
    "value": {
      "default": "bar",
      "type": "enumeration",
      "enum_values": [{
        "bar": "Bar Chart"
      }, {
        "line": "Line Chart"
      }],
      "required": true
    },
    "details": {
      "label": "Chart types",
      "description": "Select the chart type to generate for the dataset"
    }
  }]
}
```

It's easiest to think of the JSON description as having 3 basic components: metadata, inputs, and parameters. The metadata includes information about the app name and version,  where it should run, where the application assets (such as the pyplot code itself) are stored, etc. Inputs are the user-supplied input data that the app needs to run. In this example, pyplot will take a single input file as an input. We call the input file `dataset` for lack of a better term. We also specify that this is a required field any time someone runs our app. Finally, parameters are the user-supplied options passed to the pyplot app at runtime. We will talk more about how this is done when we create our wrapper template. For now we point out that we are defining a single input of type enumeration with possible values <em>bar</em> and <em>line</em>. Like our input, this parameter is required.

There are many, many other attributes and options that we could include in our app description. We will get to some of them in the intermediate and advanced examples. For a full description of all the app description attributes and options, see the <a href="http://agaveapi.co/documentation/tutorials/app-management-tutorial/app-inputs-and-parameters-tutorial/" title="App Inputs and Parameters Tutorial">App Inputs and Parameters Tutorial</a>.

### Creating a wrapper script

Now that we have our app defined, we need to create a wrapper template that Agave can use to run our pyplot code. A wrapper template is a shell script that Agave calls to invoke your app. A simple wrapper template for our app is shown below.

[code lang=text]
WRAPPERDIR=$( cd "$( dirname "$0" )" && pwd )

# The input file will be staged in for you as part of the job request.
# Here we just sanity check that it exists.
if [[ ! -e "${dataset}" ]]; then
    echo "Input file '${dataset}' was not found in the job directory" >&2
    exit 1
fi

# We will drop the output graphs into a standard place
outdir="$WRAPPERDIR/output"
mkdir -p "$outdir"

# Now run the pyplot app with the injected chart type and directory as commandline options
python $WRAPPERDIR/lib/main.py -v --output-location=$outdir --chart-type=${chartType} ${dataset}
```

You may notice that the wrapper template contains references to the `dataset` and `chartType` properties we defined in our app description. These are what we call template variables. Template variables are placeholders in the wrapper template that will be replaced with runtime values during job submission.

When a user runs this example app, they will specify a `dataset` and `chartType` in their job request. During job submission, Agave will stage the `dataset` to the execution system, demo.execute.example.com, and place it in the job's work directory. It will then copy the contents of the app's `deploymentPath`, apps/pyplot-demo-basic-0.1.0, from the `deploymentSystem`, demo.storage.example.com, to the job work directory on demo.execute.example.com and process the contents of the wrapper template, wrapper.sh, into an executable file.

During processing, Agave will replace all occurrences of `${dataset}` and `${chartType}` with the name of the input file that it staged to the job work directory (not the full path, just the file name) and the user-supplied `chartType` value. Depending on whether the execution system registered with Agave uses a batch scheduler, specifies a custom environment, or requires other custom environment variables set, Agave will prepend these values to the top of the file, resolve any other predefined template variables in the wrapper, and save the file in the job work folder and executed.

### Things you don't worry about

#### Data staging

Data will already be there before the app is run. If the data isn't available or the user didn't provide any, the job will fail before the wrapper template is processed.

#### Logging

Logging is handled for you by Agave. Both stderr and stdout will be captured for CLI apps. On batch systems, the job log files are saved in the job work directory. All will be present in the job work directory or archive directory when the job completes.

#### App installation

This is a bit of a moot point since pyplot is Python, but Agave handles the app staging for you by copying the `deploymentPath` from the `deploymentSystem` given in your app description to the job work folder on the `executionSystem`. As long as you can package up your app's assets into the `deploymentPath`, or ensure that they are already present on the system, you can run your app without dealing with pulling in dependencies, etc.

Of course, you still have the option of including a build or compilation in your wrapper script. For throughput reasons, however, that may not be the best approach. For another option with much better portability and performance, see the Docker App Containers Tutorial.

### Testing the wrapper template

To test our wrapper template, we will create a new script in our test folder. The script will define the template variables Agave would replace in the wrapper template at runtime. One perk of the wrapper templates being shell scripts is we can simply define our inputs and parameters as environment variables and bash will do the replacement for us.

[code lang=text]
#!/bin/bash

DIR=$( cd "$( dirname "$0" )" && pwd )

# set test variables
export dataset="$DIR/lib/testdata.csv"
export chartType="bar"

# call wrapper script as if the values had been injected by the API
sh -c ../wrapper.sh
```

That's it. We can run the script and verify that the correct bar chart appears in the output directory.

### Registering your app

Now that we have our wrapper script and app description, and we have tested it works, we will register it to Agave. Let's copy our wrapper script and test directory up to the `deploymentSystem` we specified in the app description and then send our app description to Agave.

```shell
files-mkdir -N apps/pyplot-demo-basic-0.1.0 -S demo.storage.example.com
files-upload -F wrapper.sh -S demo.storage.example.com apps/pyplot-demo-basic-0.1.0
files-upload -F test -S demo.storage.example.com apps/pyplot-demo-basic-0.1.0

apps-addupdate -F app.json
```

That's it. Now we have our app ready to run with Agave.

### Running your app

To run your app, we will post a JSON job request object to the jobs service. We can get an sample job description from the Agave CLI's `jobs-template` script.

```shell
jobs-template -A demo-pyplot-demo-basic-0.1.0 > submit.json
```

That will produce JSON similar to the following in the `submit.json` file.

```javascript
{
  "name": "demo-pyplot-demo-basic test-1415742730",
  "appId": "demo-pyplot-demo-basic-0.1.0",
  "archive": false,
  "inputs": {
    "dataset": "agave://demo.storage.example.com/apps/pyplot-demo-advanced-0.1.0/test/testdata.csv"
  },
  "parameters": {
    "chartType": "bar"
  }
}
```

We can now submit this JSON to the jobs service to run our pyplot on the execution system.

```shell
jobs-submit -W -F submit.json
```

When the job ends, you can use the `jobs-output` CLI script to retrieve the output. Here `$JOB_ID` is the id returned from the previous job submission.

### Accessing job output

```shell
jobs-output -P output/bar.png -D $JOB_ID
```

gha_language: HTML


text:
# BABD-Scalabale-data-and-processing
 Project for BABD Master @ MIP - Politecnico di Milano.

 Designed, developed and tested by:
 * Gabriele Sartor
 * Matteo Canale
 * Matteo Gatto
 * Federico Pomè
 * Fabio Dopudi

# Main components
 The project aims to exploit scalable technologies both for storing data and processing them.
 A MongoDB instance is populated with data from reddit through a daemon script in python and the data can be accessed using an API developed with the [FastAPI Framework](https://fastapi.tiangolo.com/).
 A Redis cache layer is used to store some reccurent queries on a daily base.
 Eventually, there is a jupyter notebook with some ML models which predict the probability of a company going bankrupt based on their balance-sheet and other financial indicators.

# Quick Setup
 The project is built on Docker using docker-compose to orchestrate containers. Two docker-compose files are available, one for development purposes and one ready for production (considering the nature of the project security concerns are only partially accounted for)

 To quickly run the application some steps are needed:
 1. Create mongo configuration file and fill it with user credentials and starting collections and indexes
    ```bash
    cp mongo/init/mongo-init.example.js mongo/init/mongo-init.js
    ```
 2. Create secrets.env file and fill it with Mongo credentials and an API-key (You can generate one using [uuid4](https://www.uuidgenerator.net/))
    ```bash
    cp secrets.example.env secrets.env
    ```
 3. Edit docker-compose files with your domain and services/traefik/traefik.prod.toml with your personal email account
 4. Run `docker-compose up -d --build`

# Future possible developments
 * Deploy the ML model and make it available through the API for real-time and custom predictions


text:
Geekification Of GIS
=====================

##Slide 1 - Grayson Perry

I have an admission to make - this presentation was inspired by a tranvestite potter from Essex.

Last year the english artist Grayson Perry gave a series of lectures for the BBC called the Reith lectures. In one of his lectures he explored the boundaries of what is and isn't art.

Listening to Grayson Perry discuss egdes of the Art world made me consider the world I inhabit in the same way - It made we want to explore the boundaries of GIS.

## Slide 2 - The Edges are Blurred'

So, I'd like to spend the next 20 minutes or so exploring the boundaries where GIS and what could be considered 'broader IT' converge.

I think the quote from Vanessa Lawrence from the Ordnance Survey is very apt. At Geoplex we often operate where the edges are blurred and I'd like to share with you today some insight into some technology which is straying into the GIS domain - in effect highlighting what I'm calling the 'Geekification of GIS'.

## Slide 3 - Beating the Bounds

To help set the scene I'm going to begin by using a reference which Grayson Perry makes in his lecture - A reference to an Ancient English tradition

Beating the bounds was a custom where by younger members of the community were escorted around the boundaries of their villages to help share knowledge of where they lay.

CLICK

At each village 'marker' the children were beaten. Essentially trying to embed a map by memory association. Children would be familiarised with the bounds of their village based upon a good old beating at the boundary

Rest assured I'll refrain from the beating today as we visit the markers around the boundaries of GIS

## Slide 4 - Markers

So as we beat the bounds this afternoon we're going to visit three markers: Search, Change and Maps Online. These markers represent three constants of GIS implementations.

At each marker I'll ask the questions:

What does our traditional view of the marker look like?
What is disrupting the marker?

....and finally

What might the future look like

## Slide 5 - Wally

It's quite ironic that Maps are meant to help us find things more easily. The current landscape of GIS applications and 'spatial data catalogues' tend to fail at providing useful search capabilities. They remind me of reading Where's Wally books to my kids.......frustrating.

Imagine if everything on our maps was searchable?

## Slide 6 - Spatial databases are good for spatial data

Our traditional way of searching has focussed on searching the data sources that underpin our maps. But what if we think about it differently. What is we ask ourselves the question what's the best environment to put our data into to make it easier to search our data. Where would we look?

Our exacting nature means we believe our audiences want exact results

Most spatial search seems to begin by assuming the audient knows what they want to search for!

Are we using the right tool for the job?

## Slide 7 - Matching expectations

Over the past year at Geoplex we've been using Elasticsearch to support search requirements

Elasticsearch is a document orientated search engine based upon the Apache Lucence project. It supports both unstructured and structured search and importantly does so in near real time!

By using elasticsearch we're able to meet the expectations of our user base, we're enabling search in our applications which matches the search experience they encounter elsewhere on the internet.

## Slide 8 - Geo-Power

Furthermore

Being able to combine free text search with geo location is the crucial next step for our applications

Elasticsearch now includes support for spatial datatypes. Not only can we ask for information based upon an attribute of that information, but we can ask for information based upon where it exists.

Now you could argue - this is not really disruptive, we've been searching for things spatially for years

...but our executions have not been targeting our audiences expectations, this is where technology like Elasticsearch has a role to play. What we are learning is that the solutions like Elasticsearch which have been built for indexing and searching millions of log records also have an application when it comes to indexing and searching millions of geo events.

## Slide 9 - I'll give you my 'geodatabase' when you pry it from my cold dead hands!

Well I know those in the old guard might be thinking to themselves....you'll not get rid of those spatial databases, but where those spatial databases live may well be challenged - how we manage databases and what we consider to be our storage options is changing. The release of Postresql & PostGIS in Amazon's RDS is a great step forward.

The fact is that the future is no longer neatly locked into a single stack of technology.

The future involves more and more data! And as the volume of our data increases we need better ways to search it.

We need to understand what tools best fit our requirements. We're backing search technology, not GIS technology when it comes to searching!

## Slide 10 - The Great Divide.

We work with alot of organisations which want to know what's changed, when and by who. However this sort of requirement has traditionally been met by big expensive solutions.

In my first job as a GIS Analyst we used to 'Merge and Post' overnight a long drawn out reconciliation of changes made across all the GIS editors in the organisation.

These large version management solutions like Smallworld merge and post of Esri's ArcSDE have remained the realm of those with deep pockets. Meanwhile many organisations have shy'd away from their cost and complexity and gone without at a further cost. This essentially represents the great divide of change management in GIS today.

## Slide 11 - Please don't do this at home....

So what's changing? Well if we step outside our little world for a moment and look into the software development world we'll notive that Software engineers had been using this thing called version control for quite some time to manage source code.

Multiple people could edit source code files at the same time and a system would track all these changes as well as provide ways to manage conflict resolution where conflicting changes occurred to the same file.

This sounds like something we could benefit from...

## Slide 12 - Map Diffing in GitHub

Over the last 5 years Git has emerged as the version control system of choice.

Not only has it become popular amongst the IT world - it has become a growing platform for collaboration across non-it professionals. The City of Chicago for example has released a series of data openly via GitHub.

But how is this brave new world effecting our traditional world and how might it help us?

Well, companies like GitHub are now able to store and version control certain types of spatial data. In the example behind me you can see how you can visualise changes in geojson data committed to github.

## Slide 13 - Geogit

GeoJson and Github might be just the first step on our journey towards a brighter future where we can manage change in our spatial data more easily and cost effectively.

I think one of the most exciting projects in this space is the GeoGit project being spearheaded by Boundless.

Boundless have essentially created a branch of Git which allows you to commit a wider range of spatial data formats, such as Shapefile, PostGIS and SQL Server. Once committed into your GeoGit repository the data is tracked at the feature level. Any committed version can be differnced and exported.

## Slide 14 - Crowded Space

It's a crowded space out there in the mapping world. Ask Rohan :)

Surely everything has been done, we have static maps, dynamic maps, slippy maps, a million map API's, we have vector in the browser, we have temporal display, we have even have live twitter maps. Is there anything else left to do?

Does the crowd mean it can't be disrupted? Of course not, in my next example we'll see a disruption which is targetted towards combining together three factors which have been arguably absent until recently

These three factors are: Cost, Ease, Power

## Slide 15 - CartoDB

CartoDB has packaged the power of PostGIS into an interface where you can easily load spatial data and create powerful visualisations within a few clicks, and importantly they are doing so at a price point which disrupts the traditional model.

The map behind me shows the spread of the American Post Office network over a 10 second period...representing just under 400 years.

## Slide 16 - Incremental Innovation

One of the most disruptive features of CartoDB is arguably not it's most obvious.

The idea of creating map tiles is not exactly new. Ever since Google reinvented web mapping in 2005 we've been caching map tiles left, right and centre. But the accepted mantra during this period has been only cache what doesn't change - now whilst this is still true in many cases, it's no longer a universal truth.

CartoDB, allows you to create map tiles on demand which are dynamic - what do I mean by dynamic? Well I can request a map, choosing what features are displayed and how they are displayed - all at runtime.

This is not new! I hear you cry - No you're right this is how all map servers essentially work - but what's new about it is that it works at scale, online and its affordable. This is essentially the evolution of online mapping

## Slide 17 What's next?

This one's far too hard to call! But I can't stand up here without putting my neck on the line so here goes...

1. I think we'll be revisiting our text books and trying to remember what raster analysis was all about, only this time we'll be able to do it online, in the browser - Like this excellent example from Mapbox which shows browser based dynamic hillshading.

2. With solutions like CartoDB finally the ultimate goodies in the spatial database toolbox are being let out - so I think we'll see spatial operators become a first class language. What I mean by that is that the wider world will become much more familiar with the classic spatial relations we know and love.

3. The visualisation revolution will continue - our perception of who is qualified to make maps will continue to be challenged by people creating maps outside of thr GIS world. This is particularly being driven by the boom in data science.

So before we conclude our journey around the boundaries of GIS, lets just briefly ask the question:

Why are the boundaries of GIS being blurred? Well I think there are two key reasons:

## Slide 18 - Digital Natives

The first reason is the ever increasing population of digitial natives. It is arguably the combination of digital natives with an entrepreneurial appetite which is leading to innovation in our industry and I for one think this is a really positive thing.

## Slide 19 - The Enabler

The second reason is the maturity of open source technology as an enabler - in each of the examples given this afternoon, open source has played a vital role. Elasticsearch wouldn't exist without Lucene, Github without Git and finally CartoDB without PostGIS and Mapnik.

A closed proprietary eco-system is not devoid of innovation, but the geekification of GIS is flourishing under the influence of open source.

I hope you've enjoyed out very brief tour around the boundaries of GIS and I hope you agree with me when I say that the future for spatial technology and data is very exciting indeed.

repository: mapbutcher/geekification-gis

repo_name: mapbutcher/geekification-gis


text:
# Netty Client to Client Relay

[![English](https://img.shields.io/badge/language-English-orange.svg)](README.md) [![Korean](https://img.shields.io/badge/language-Korean-blue.svg)](README_kr.md)

## 1. What is Netty Client to Client Relay?

***Netty Client to Client Relay*** is a utility program that uses an relay server to connect TCP socket communication between a client and a server using outbound traffic, just like the communication between a client and a client.

## 2. How is it different from traditional relay tools?

In the case of the existing relay tool represented by ***socat***, inbound communication from the relay server to the legacy server had to be possible. As a result, there are two major limitations:

1. Inbound communication from the relay server to the legacy server must be possible.
2. The relay server must know the IP address of the legacy server.

If the legacy server cannot communicate inbound due to firewalls or other restrictions on the network, the existing relay tool could not connect the client to the server. Also, even if the legacy server you want to use uses a dynamic IP address instead of a static IP address, the existing relay tool could not be applied.

***Netty Client to Client Relay*** avoids the limitations of existing relay tools by creating a new client from the legacy server and connecting to the relay server when a client connection to the legacy server occurs without changing the legacy server.

Through this, it is possible to reduce costs by relaying a high-performance local server using a dynamic IP address through a low-performance cloud server VM using a static IP address.

In addition, it can be used for remote access via RDP to a PC in a space where inbound traffic is restricted by a firewall.

## 3. Features

***Netty Client to Client Relay*** has the following features:

* The new legacy server connection is turned into a client connection and connected as a relay server.
* When a new client connects to the relay server, new clients are also generated and connected to the legacy server and relay.
* It does not affect the communication of the legacy server and client.
* It can run in any OS environment that can run JVM.
* Multiple clients can connect simultaneously with one relay server and a legacy server.
* Available for all protocols based on TCP.
* It uses less resources on the relay server.

## 4. Restrictions

***Netty Client to Client Relay*** has the following restrictions:

* ***Netty Client to Client Relay*** is not a VPN. Therefore, at present, the communication section is not encrypted. If encryption for the data communication section is required, please apply communication encryption between the legacy server and client.
(Communication section encryption will be applied in the future.)
* ***Netty Client to Client Relay*** does not currently support logging. Logging will be added in the future.
* ***Netty Client to Client Relay*** does not have a feature to automatically reconnect when the connection between the relay server and the legacy server is lost. Please refer to it when using.

## 5. Download

[Latest release](https://github.com/kyuseok-oh/netty-client-to-client-relay/releases)

***Netty Client to Client Relay*** consists of two files: `client2client.jar` and `server2server.jar`.

* Please download the `client2client.jar` file to the legacy server.
* Please download the `server2server.jar` file to the relay server.

## 6. How to use

***Netty Client to Client Relay*** is built and tested with OpenJDK 1.8. Therefore, OpenJDK 1.8 or higher installation is required on each server for use.

> In order to run the server, first execute `server2server.jar` of the relay server, and then execute `client2client.jar` of the legacy server.

The usage of the relay server's `server2server.jar` file is as follows.

```txt
java -jar [Path of This JAR] [Server2Server Port] [(Optional) API Auth Key]
```

Each parameter is as follows.

* [Path of This JAR] : The path to the `server2server.jar` file.
* [Server2Server Port] : The port to be used by the `server2server`.
* [(Optional) API Auth Key] : It is a key string required for API encryption and authentication with the legacy server, and input an arbitrary string. If no input, a key is randomly generated during the relay server execution process and the key string is output on the screen.

The usage of `client2client.jar` file of the legacy server is as follows.

```txt
java -jar [Path of This JAR] [Inbound Port for Your Server App] [Server2Server Address] [Server2Server Port] [API Auth Key]
```

Each parameter is as follows.

* [Path of This JAR] : Path to `client2client.jar` file.
* [Inbound Port for Your Server App] : The port on which the existing server program is listening.
* [Server2Server Address] : Address of the relay server.
* [Server2Server Port] : Port specified by `server2server` program of the relay server.
* [API Auth Key] : It is a key string required for API encryption and authentication with the relay server. Please enter the same string generated by the relay server or the same string entered when start the relay server.

The following is an example of relaying an legacy server SSH connection to a client via relay server. In this example, when a client connects to port 4000 of the relay server (<IP_ADDRESS>), TCP connection is made to port 22 of the legacy server.

* Example of how to use a server2server (when using a custom API Auth key)

```sh
java -jar ./server2server.jar 4000 testApiAuthKey
```

* Example of how to use a client2client (when using a custom API Auth key)

```sh
java -jar ./client2client.jar 22 <IP_ADDRESS> 4000 testApiAuthKey
```

The following example is identical to the example above, but uses an auto-generated API Auth key instead of a custom API Auth key.

* Example of how to use a server2server (when using a auto-generated API Auth key)

```sh
java -jar ./server2server.jar 4000
```

Console Output :

```sh
Generated API Auth Key :
uUFwcbknu78fzZ5uXjE_v5J_AQRd3c5F
```

* Example of how to use a client2client (when using a auto-generated API Auth key)

```sh
java -jar ./client2client.jar 22 <IP_ADDRESS> 4000 uUFwcbknu78fzZ5uXjE_v5J_AQRd3c5F
```


text:
### Changing authentication methods

IIS supports a number of authentication methods. As described above, these are "locked" to `applicationHost.config` by default - so if you want to automatically enable them. The examples below show how to enable/disable:

 - Anonymous authentication
 - Basic authentication
 - Digest authentication
 - Windows authentication

IIS Manager also shows "ASP.NET impersonation" and "Forms authentication" as settings at the same level, but these are actually set in your app's `web.config` file so I've left them out of here.

repository: ekirmayer/PowerShell-IIS-Examples

repo_name: ekirmayer/PowerShell-IIS-Examples


text:
# MicrogridGT

MicrogridGT is a Python library for dealing with dispatch of energy resources in a constrained environment

## Usage
To run created tests
```sh
sh ./TestDieselRampUp.sh
sh ./TestElectricGridCosts.sh
```
To test directly in python
```python
dispatchGT.py [-h] [-a ALPHA] [-d1 POWERBALANCE] [-d2 NASHEQUILIBRIUM]
                     [-pvuep PVUEP] [-wtuep WTUEP] [-deuep DEUEP]
                     [-btuep BTUEP] [-lduep LDUEP] [-egtm EGTM] [-pvumc PVUMC]
                     [-wtumc WTUMC] [-deumc DEUMC] [-btumc BTUMC]
                     [-egumc EGUMC] [-deop DEOILPRICE]
                     [-derc DERATECONSUMPTION] [-demin DEMINPOWER]
                     [-demax DEMAXPOWER] [-deru DERAMPUP] [-derd DERAMPDOWN]
                     [-demrt DEMINRUNNINGTIME] [-deaoc DEAOILCONSUMPTION]
                     [-deboc DEBOILCONSUMPTION] [-decoc DECOILCONSUMPTION]
                     [-btsd BTSELFDIS] [-btrc BTRATEDCAP] [-btc BTC]
                     [-btde BTDISCHARGEEFF] [-btce BTCHARGEEFF]
                     [-btsmx BTSOCMAX] [-btsmn BTSOCMIN] [-btsi BTSOCINIT]
                     [-ldws LDWEIGHTSAT] [-ldb LDBETA] [-lda LDALPHA]
                     [-tn TESTNAME] [-sa SAMPLESTOANALIZE] [-pg] [-ds DATASET]

```

Name of variable | Default value| Description
-----------------|----------------|------------
alpha  |ALPHA = 0.1 |  Weight of power balance
powerbalance |POWERBALANCE = 2|  Update of alpha in case power balance is not reached
nashequilibrium | NASHEQUILIBRIUM = 4 |  Update of alpha in case nash equilibrium is not reached
pvuep  |PV_UEP =  2  |  Photovoltaics unit electric price
wtuep  |WT_UEP =  4  |  Wind turbine unit electric price
deuep  |DE_UEP =  4  |  Diesel unit electric price
btuep  |BT_UEP =  0.1|  Battery unit electric price
lduep  |LD_UEP =  0.4|  Load unit electric price
egtm |EGTM =  20|  Electric grid unit tariff multiplier
pvumc  |PV_UMC = 0.5 |  Photovoltaics unit maintenance cost
wtumc  |WT_UMC = 3.0 |  Wind turbine unit maintenance cost
deumc  |DE_UMC = 3.0 |  Diesel unit maintenance cost
btumc  |BT_UMC = 0.05|  Battery unit maintenance cost
egumc  |EG_UMC = 0.02|  Electric grid unit maintenance cost
deoilprice |DE_OP = 3.0  |  Oil price. Be consistent with units of DE_RC
derateconsumption  |DE_RC = 2 |  Oil rate consumption. Be consistent with units of DE_OP
deminpower |DE_MIN = 0 |  Min diesel power
demaxpower |DE_MAX = 10 |  Max diesel power
derampup |DE_RAMP_UP = 20 |  Diesel ramp up diesel
derampdown |DE_RAMP_DOWN = 10  |  Diesel ramp down diesel
deminrunningtime |DE_MIN_RUNNING_TIME = 0.3  |  Diesel min running time
deaoilconsumption  |DE_A_OIL_CONSUMPTION = 1 |  Factor to model quadratic term in diesel consumtion function
deboilconsumption  |DE_B_OIL_CONSUMPTION = 2  |  Factor to model linear term in diesel consumtion function
decoilconsumption  |DE_C_OIL_CONSUMPTION = 1  |  Factor to model constant term in diesel consumtion function
btselfdis  |BT_SELF_DIS = 0.0000001 |  Battery self discharge by operating cycle
btratedcap |BT_RATED_CAP = 10  |  Battery rated capacity in kWh
btc  |BTC =  |  C factor to model battery behavior
btdischargeeff |BT_DIS_EFF = 0.99  |  Discharge efficiency in battery
btchargeeff  |BT_CHAR_EFF = 0.99 |  Charge efficiency in battery
btsocmax |BT_SOC_MAX = 100 |  Max SOC allowed in battery in percentage. Usually 100
btsocmin |BT_SOC_MIN = 60  |  Min SOC allowed in battery in percentage.
btsocinit  |BT_SOC_INIT = 70  |  Starting SOC for simulation.
ldweightsat  |LD_WEIGHT_SAT = 0.9 |  Load weight factor of satisfaction.
ldbeta |LD_BETA = -1  |  Factor to model satisfaction of load function
ldalpha  |LD_ALPHA = 0.5  |  Factor to model satisfaction of load function
testname |TEST_NAME = Test  |  Folder name to save tests to run
samplestoanalize |SAMPLES_TO_ANALIZE = 20  |  Number of units of time to analize
playwithgrid |TRUE if -pg included | Option to include player electric grid to the game
dataset  |DATA_SET_FILE_NAME =  '../FormattedDataSets/dataWithoutBatteries.csv' |  Name of dataset for initial resources and load data

## 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.

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

repository: mamontesp/MicrogridGT

repo_name: mamontesp/MicrogridGT