text:
---
# Concert Name (e.g. "Fall Concert")
concertName: "Spring Concert"
# Concert Color theme (use hex form of sRGB to find)
colorTheme: "#7E57C2"
# Date YY-MM-DD (for sorting)
date: "1993-04-00"
# Season
season: "1992/93"
# Is current season?
current: "false"
# Poster filename (without extension)
poster: "beethoven"
# Google Calendar link (if applicable)
calendar: ""
# Ticket link (if applicable)
tickets: ""
# Livestream link (if applicable)
stream: ""
# Youtube link (if applicable)
youtube: ""
# Spotify link (if applicable)
spotify: ""
---
Title = Beethoven Symphony No. 9
Subtitle = Michael Pratt, Conductor
Subtitle = Princeton University Glee Club

Section

Hall = Richardson Auditorium in Alexander Hall
Generaltime = April 1992

Section

Overline = Program
Work = W. A. Mozart ~ Overture to *Don Giovanni*, K. 527
Work = Joseph Haydn ~ Cello Concerto No. 1 in C major, Hob. VIIb/1
Break = --- Intermission ---
Work = Ludwig van Beethoven ~ Symphony No. 9 in D minor, op. 125

repository: ReillyBova/PUO-Website

repo_name: ReillyBova/PUO-Website


text:
---
title: "Study netlify"
date: 2019-09-03T10:40:25+03:00
draft: true
description: ""
tags:
categories: bash,
type: post
url:
author: "Mert Nuhoglu"
output:
  html_document:
    css: styles.css
blog: mertnuhoglu.com
resource_files:
path: ~/projects/study/code/study_netlify
state: wip

---

## Deploy hugo on netlify

ref: `Deploy on Netlify <url:/Users/mertnuhoglu/projects/study/code/study_hugo.md#tn=Deploy on Netlify>`

``` bash
netlify sites:list
  ##> serene-williams-91452b - 55708760-0daa-4e2b-8dcc-0fe92e90b727
  ##>   url:  https://serene-williams-91452b.netlify.com
  ##>   repo: https://github.com/mertnuhoglu/testnetlify04
  ##>   account: Mert Nuhoglu's team
```

repository: mertnuhoglu/study

branch_name: refs/heads/master

extension: md

gha_language: HTML

license_type: permissive

repo_name: mertnuhoglu/study


text:
# ocp_prompt
A simple ocp prompt for zsh

For installing simply place it under your custom folder for zsh config, ie ~/$ZSH/custom and source it from your ~/.zshrc

If you want to customize the PROMPT, edit either OC_PROMPT_SEP which by default is set to / or simply PROMPT.

You will get something like this:

➜  kvm-install-vm  ocp:(myproject/sfo1) git:(master) ✗

where myproject is current namespace and sfo1 current cluster.

license: MIT


text:
# Shopping for AirPods Pro? Here’s how to find available stock without waiting weeks

Published at: **2019-11-05T18:53:30+00:00**

Author: **Michael Potuck**

Original: [9to5Mac](https://9to5mac.com/2019/11/05/how-to-check-airpods-pro-stock-apple-amazon-best-buy/)

If you didn’t pick up AirPods Pro when they launched, you might be having a tough time finding them. Follow along for a look at how to check AirPods Pro stock at Apple Stores, Amazon, Best Buy, and more to get a pair without waiting for weeks.
AirPods Pro availability was quite good when they launched at the end of October. However, shipping times have slipped and in-store stock at retailers can be tricky to find.
Alternately, you can check out stock aggregation sites like iStockNow to keep an eye on AirPods Pro availability and even set up alerts.
FTC: We use income earning auto affiliate links. More.

license: Unlicense

repository: dsadlollioygjmzvcxv/tdc-exported

repo_name: dsadlollioygjmzvcxv/tdc-exported


text:
# FLEXOUT: YOUR PERSONAL MOBILE DRILL INTRUCTOR

## Description;

The flexout app is an Ironhack Berlin 2021 Web development project made by @kumax0 and @andalucinando. With this app you can research different exercices clustered in different categories depending on what part of the body you want to excercise.

The main functionalities of this mobile web-app are;

- Check out more than 400+ Exercises with  descriptions.
- Create your custom workouts by selecting from all the exercices, you can create different workouts for different days or create a specific workout for parts of your body, your call.

## About the WGER API;

Wger is a collaborative open source project, made by fitness enthusiasts from around the world.

--> Source Code; https://github.com/wger-project

Wger Workout Manager provides a full REST API to all database objects: https://wger.de/api/v2/

## License

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

repository: FlexOut/Flexout

repo_name: FlexOut/Flexout


text:
---
book:
  author: Laura Steven
  cover:
    name: the-society-for-soulless-girls.jpg
    tint_color: "#0c4b87"
  title: The Society for Soulless Girls
  publication_year: 2022
  isbn13: "9781405296939"
  tags:
    - fiction
    - fantasy
    - magic
review:
  date_read: 2022-09-21
  format: paperback
  rating: 4
---

This was a fun and quick read: Alice and Lottie are students at a newly-reopened school famous for a string of mysterious deaths.
The book alternates between their points of view, as Lottie becomes possessed by a dark force and Alice splits her soul in an ill-fated ritual – drawing them into the dark history of the school.

I like the overall plot, which is really about male attitudes to women's anger; it hangs together nicely as a theme.

Some elements felt a little underdeveloped – like the romance between the two protagonists – and the ending came together quite quickly.

I enjoyed it, but I didn't love it.

branch_name: refs/heads/live

gha_language: Rust

gha_license_id: MIT


text:
# Introduction

TrivialCube can compute full or partial cube with sum or count aggregate function.

The imput file must have at most 9 columns

# required

* Java

* Maven

(To install maven in debian/ubuntu: `sudo apt-get install maven2`)

# Install

* git clone https://github.com/hhachim/trivialcube.git

* cd trivialcube

* mvn clean package

# Run

* usage:

```sh
java -jar target/trivialCube-1.0-SNAPSHOT-jar-with-dependencies.jar
```

    -c,--column <arg>               (Optional) The column position (first
                                    column position is 0) containing the
                                    values to compute for the sum aggregate
                                    function
    -d,--output-dimensions <arg>    (Optional) The dimensions to compute
                                    (defaut : all dimensions), ex
                                    -d='1,0-1-3,3-2' to compute only theses
                                    three dimensions
    -f,--aggregate-function <arg>   The aggregate function to
                                    compute(possible values : sum or count)
    -i,--input-file <arg>           The input file containing the data to
                                    compute
    -o,--ouput-directory <arg>      The ouput directory to store the cube

* All cuboids (dimensions) with sum aggregate :

```sh
java -jar target/trivialCube-1.0-SNAPSHOT-jar-with-dependencies.jar -i="./samples/table.txt" -f=sum -o="/tmp" -c=3
```

* All cuboids (dimensions) with count aggregate :

```sh
java -jar target/trivialCube-1.0-SNAPSHOT-jar-with-dependencies.jar -i=./samples/table.txt -f=count -o=/tmp
```

* One specific cuboid

```sh
java -jar target/trivialCube-1.0-SNAPSHOT-jar-with-dependencies.jar -i=./samples/table.txt -f=sum -o=/tmp -c=3 -d="1"
```

* Many specific cuboids (example cuboid 0-1, and cuboid 1-3)

```sh
java -jar target/trivialCube-1.0-SNAPSHOT-jar-with-dependencies.jar -i=./samples/table.txt -f=sum -o=/tmp -c=3 -d="0-1,1-3"
```
License
----

MIT

repository: hhachim/trivialcube

repo_name: hhachim/trivialcube


text:
---
title: New dredging technology may be
tags:
  - Mar 1995
---

New dredging technology may be used in a plan to deepen the Miami River from 13 to 15 feet.

Newspapers: **Miami Morning News or The Miami Herald**

Page: **2**, Section: **B**


text:
#MonkeyBrains

MonkeyBrains is a sophisticated AI Engine for jMonkeyEngine. It uses an agent framework to wrap human and AI controlled characters in plugin-based AI algorithms so that different each game can pick out whichever AI techniques fits best.

##User Guide for MonkeyBrains:
User guide for MonkeyBrains has been made and you can see it:
https://github.com/QuietOne/JMEAI/blob/master/User%20Guide%20for%20MonkeyBrains.md

##Note:

If you have suggestion or any questions, please see forum:
http://hub.jmonkeyengine.org/forum/board/projects/monkeybrains/

##Licence:

Distributed under the BSD licence.


text:
## Sample 2: Selected Items

The `IsSelected` property defines whether the list item is selected or not.

Selected items are not clickable by default - the links are not rendered. You can set `RenderLinkForSelectedItem` to `true` if you want to render links even for selected items.

repository: riganti/dotvvm-docs

gha_language: C#

repo_name: riganti/dotvvm-docs


text:
# Alegrify app (React Native)

Alegrify was a web service to improve your mental health by challenging your own thoughts.
While the service is offline, the app can still be used, allthough all of the features that required networking have been removed.

## Architecture

The app has been built upon a basic react-redux architecture.

### Actions

[Take a look at all actions](https://github.com/dejakob/react-native-alegrify-offline/tree/master/src/store-actions)

### Reducers

There's obviously only one reducer but this combines several subreducers.
[Take a look at all reducers](https://github.com/dejakob/react-native-alegrify-offline/tree/master/src/store-reducers)

### Effects

As Redux actions are always syncronous, some 'effects' have been added to guarantee support for asyncronous actions.
[Take a look at all effects](https://github.com/dejakob/react-native-alegrify-offline/tree/master/src/store-fx)

## Automated tests

To be able to run the automated tests, be sure you're using OS X as all tests use XCode.
Before running the tests on your machine, make sure detox and the following packages are installed:

```bash
brew tap wix/brew
brew install --HEAD applesimutils
npm install -g detox-cli
npm install -g react-native-cli
```

## Languages

Both Dutch and English are supported. i18next has been used to make this possible.

## User Interface

The User Interface has been built with components from the [react-native-alegrify-ui](https://www.npmjs.com/package/react-native-alegrify-ui) package. Take a look [here](https://dejakob.com/react-native-alegrify-ui) to read the docs.

## Used sources

The images in the app have been licensed by the author as 'free to use'.
Check out the links to have the images in their original formats.

* https://www.pexels.com/photo/person-on-a-bridge-near-a-lake-747964/
* https://www.pexels.com/photo/person-leans-on-arms-with-sad-text-1927571/
* https://www.pexels.com/photo/blonde-hair-blur-daylight-environment-214574/
* https://www.pexels.com/photo/light-sky-space-abstract-40748/
* https://www.pexels.com/photo/man-couple-people-woman-343/

repository: dejakob/react-native-alegrify-offline

gha_language: JavaScript

repo_name: dejakob/react-native-alegrify-offline


text:
Simply call `rivets.bind` on a template element with some data that you would like to bind.

```javascript
rivets.bind($('#auction'), {auction: auction})
```

*Every call to `rivets.bind` returns a fully data-bound view that you should hold on to for later. You'll need it in order to unbind it's listeners using `view.unbind()`.*

repository: QAPInt/rivets

repo_name: QAPInt/rivets


text:
## Install GPRS_C_SDK toolchain

* [installation doc](https://ai-thinker-open.github.io/GPRS_C_SDK_DOC/en/c-sdk/installation_linux.html)
* Or [docker](https://github.com/Neutree/gprs_build)

```bash
git clone git@github.com:Neutree/micropython.git
make -C mpy-cross
cd micropython/ports/gprs_a9
chmod +x build.sh
./build.sh
```

and burn the final `.lod` file in the `hex` folder.

## Platform-specific modules

### `cellular`

Provides cellular functionality.
As usual, the original API does not give access to radio-level and low-level functionality such as controlling the registration on the cellular network: these are performed in the background automatically.
The purpose of this module is to have an access to high-level networking (SMS, GPRS, calls) as well as to read the status of various components of cellular networking.

#### Classes ####

* `SMS(phone_number, message)`

  A class for handling SMS.

  **Attrs**:

    * phone_number (str): phone number (sender or destination);
    * message (str): message contents;
    * status (int): an integer with status bits;
    * inbox (bool): incoming message if `True`, outgoing message if `False` or unknown status if `None`;
    * unread (bool): unread message if `True`, previously read message if `False` or unknown status if `None`;
    * sent (bool): sent message if `True`, not sent message if `False` or unknown status if `None`;
    * `send()`

      Sends the message.

      **Raises**: `CelularRegistrationError` if not registered on the network or `SMSError` if failed to set up/send SMS.

    * `withdraw()`

      Withdraws SMS from SIM storage. Resets status and index of this object to zero.

      **Raises**: `SMSError` if failed to withdraw.

#### Exception classes ####

* `CellularError(message)`
* `CellularRegistrationError(message)`
* `SMSError(message)`
* `NoSIMError(message)`
* `CellularAttachmentError(message)`
* `CellularActivationError(message)`
* `NetworkError(message)`

#### Methods ####

##### Status and information #####

* `get_imei()`

  Retrieves the International Mobile Equipment Identity (IMEI) number.

  **Returns**: a string with IMEI number.

* `get_iccid()`

  Retrieves the Integrated Circuit Card ID (ICCID) number of the inserted SIM card.

  **Returns**: a string with ICCID number.

  **Raises**: `NoSIMError` if no ICCID number can be retrieved.

* `get_imsi()`

  Retrieves the International Mobile Subscriber Identity (IMSI) number of the inserted SIM card.

  **Returns**: a string with IMSI number.

  **Raises**: `NoSIMError` if no IMSI number can be retrieved.

* `network_status_changed()`

  Checks whether the network status was changed since the last check.

  **Returns**: `True` if it was changed.

* `get_network_status()`

  Retrieves the network status as an integer.

  **Returns**: `int` representing cellular network status.

  **TODO**: Provide bit-wise specs.

* `poll_network_exception()`

  Retrieves the network exception and raises it, if any.

  **Raises**: One of `CellularError`s occurred during the operation in the background.

* `is_sim_present()`

  Checks whether the SIM card is present and ICCID can be retrieved.

  **Returns**: True if SIM card is present.

* `is_network_registered()`

  Checks whether registered on the cellular network.

  **Returns**: True if registered.

* `is_roaming()`

  Checks whether registered on the roaming network.

  **Returns**: True if roaming.

  **Raises** `CellularRegistrationError` if not registered on the network.

* `get_signal_quality()`

  Retrieves signal quality.

  **Returns**: Two integers, the signal quality (0-31) and RXQUAL. These are replaced by `None` if no signal quality information is available.
  **Note**: The RXQUAL output is always `None`. Its meaning is unknown.

##### SMS #####

* `sms_received()`

  Retrieves the number of SMS received since the last check.

  **Returns**: the number of SMS received.

* `sms_list()`

  Retrieves SMS from the SIM card.

  **Returns**: a list of SMS messages.

  **Raises**: `CellularRegistrationError` if not registered on the network. This is because network registration process interfers with most other SIM-related operations.

##### GPRS #####

* `gprs_attach()`

  Attaches to the network. This is required for activating the GPRS context. If already attached, does nothing.

  **Raises**: `CellularRegistrationError` if not registered on the network or `CellularAttachmentError` if the attachment process failed at any stage.

  **Note**: There may be no need to run this as, after a hard reset, the module attempts to attach automatically.

  **TODO**: Consider getting rid of this function.

* `gprs_detach()`

  Detaches from the network. Does nothing if already detached.

  **Raises**: `CellularRegistrationError` if not registered on the network or `CellularAttachmentError` if the detachment process failed at any stage.

  **TODO**: Consider getting rid of this function.

* `gprs_activate(apn, user, name)`

  Activates the GPRS context. Does nothing if already activated even if different credentials were provided previously.

  **Args**:

    * apn (str): access point name (APN);
    * user (str): username;
    * pass (str): password;

  **Raises**: `CellularRegistrationError` if not registered on the network or `CellularActivationError` if the activation process failed at any stage.

  **Note**: there is no way to check whether the credentials supplied are valid.

* `gprs_deactivate()`

  Deactivates the GPRS context. Does nothing if already deactivated.

  **Raises**: `CellularRegistrationError` if not registered on the network or `CellularActivationError` if the deactivation process failed at any stage.

### `usocket` ###

TCP/IP stack based on lwIP.
See [micropython docs](https://docs.micropython.org/en/latest/library/usocket.html) for details.

#### Classes ####

* `socket(af, type, proto)`

    * `close()`
    * `bind(address)` *not implemented*
    * `listen([backlog])` *not implemented*
    * `accept()` *not implemented*
    * `connect(address)`
    * `send(bytes)`
    * `sendall(bytes)`
    * `recv(bufsize)`
    * `sendto(bytes, address)` *not implemented*
    * `recvfrom(bufsize)` *not implemented*
    * `setsockopt(level, optname, value)` *not implemented*
    * `settimeout(value)` *not implemented*
    * `setblocking(flag)` *not implemented*
    * `makefile(mode, buffering)`
    * `read([size])`
    * `readinto(buf[, nbytes])`
    * `readline()`
    * `write(buf)`

#### Methods ####

* `get_local_ip()`

  Retrieves the local IP address.

  **Returns**: The local IP address as a string.

  **Raises**: `NetworkError` if no address was assigned.

* `getaddrinfo(host, port, af=0, type=0, proto=0, flags=0)`

  *Not implemented*

  Translates host/port into arguments to socket constructor.

  **Args**:

    * host (str): host name;
    * port (int): port number;
    * af (int): address family: `AF_INET` or `AF_INET6`;
    * type: (int): future socket type: `SOCK_STREAM` or `SOCK_DGRAM`;
    * proto (int): future protocol: `IPPROTO_TCP` or `IPPROTO_UDP`;
    * flag (int): additional socket flags;

  **Returns**: a tuple with arguments.

* `inet_ntop(af, bin_addr)`

  *Not implemented*

  Converts a binary address into textual representation.

  **Args**:

    * af (int): address family: `AF_INET` or `AF_INET6`;
    * bin_addr (bytearray): binary address;

  **Returns**: a string with the address.

* `inet_pton(af, txt_addr)`

  *Not implemented*

  Converts a text address into binary representation.

  **Args**:

    * af (int): address family: `AF_INET` or `AF_INET6`;
    * txt_addr (str): address as text;

  **Returns**: a bytearray address.

* `get_num_open()`

  Retrieves the number of open sockets.

  **Returns**: The number of open sockets.

### `gps`

Provides the GPS functionality.
This is only available in the A9G module where GPS is a separate chip connected via UART2.

#### Exception classes ####

* `GPSError(message)`

#### Methods ####

* `on()`

  Turns the GPS on. Blocks until the GPS module responds.

  **Raises**: `GPSError` if the GPS module does not respond within 10 seconds.

* `off()`

  Turns the GPS off.

* `get_firmware_version()`

  Retrieves the firmware version.

  **Returns**: the firmware version as a string.

  **Raises**: `GPSError` if the GPS module fails to respond.

* `get_location()`

  Retrieves the current GPS location.

  **Returns**: latitude and longitude in degrees.

  **Raises**: `GPSError` if the GPS module never responded or is off.

* `get_last_location()`

  Retrieves the last GPS location.

  **Returns**: latitude and longitude in degrees.

  **Raises**: `GPSError` if the GPS module never responded.

* `get_satellites()`

  Retrieves the number of satellites visible.

  **Returns**: the number of satellites tracked and the number of visible satellites.

  **Raises**: `GPSError` if the GPS module is off.

### `machine`

Provides power-related functions: power, watchdogs.

#### Methods ####

* `reset()`

  Hard-resets the module.

* `off()`

  Powers the module down.
  **Note**: By fact, hard-resets the module, at least when USB-powered.
  **TODO**: Needs further investigation.

* `idle()`

  Reduces clock rates of the module keeping functionality.

* `get_input_voltage()`

  Retrieves the input voltage and the battery percentage.

  **Returns**: two numbers: the voltage in `mV` and the estimated percentage (Lithium battery discharge controller).
  **Note**: also works when USB-powered (the second number returned is irrelevant).

* `power_on_cause()`

  Retrieves the reason for powering the module on.

  **Returns**: one of `POWER_ON_CAUSE_ALARM`, `POWER_ON_CAUSE_CHARGE`, `POWER_ON_CAUSE_EXCEPTION`, `POWER_ON_CAUSE_KEY`, `POWER_ON_CAUSE_MAX`, `POWER_ON_CAUSE_RESET`.
  **Note**: never saw anything except `POWER_ON_CAUSE_CHARGE` returned.
  **TODO**: needs further investigation.

* `watchdog_on(timeout)`

  Arms the hardware watchdog.

  **Args**:

    * timeout (int): timeout in seconds;

* `watchdog_off()`

  Disarms the hardware watchdog.

* `watchdog_reset()`

  Resets the timer on the hardware watchdog.

gha_language: C


text:
# HELIOS Profile API #

## Introduction ##

The Profile Manager handles user account creation and creation of
associated keys. At least one key pair is needed for signing and
verification of electronic signatures and another public key - private
key pair is needed for encryption and decryption. Other keys are
needed for encrypting contents that the user is producing and/or
sending messages to other users. Uses HeliosKeyStoreManager and
HeliosCryptoManager from HELIOS Security and Privacy API.

HELIOS Profile API is one of the HELIOS Core APIs as highlighted in
the picture below:

![HELIOS Profile API](https://raw.githubusercontent.com/helios-h2020/h.core-Profile/master/doc/images/helios-profile.png "Profile API")

## API usage ##

See javadocs in [javadocs.zip](https://raw.githubusercontent.com/helios-h2020/h.core-Profile/master/doc/javadocs.zip).

### HeliosProfileManager ###

Provides the main functionalities, e.g. load and store attributes from
shared preferences.

Apps are expected to use `HeliosProfileManager` singleton class to
access the functionality. Applications should call the
`getInstance();` method in order to get a singleton object.

```
HeliosProfileManager profileMgr = HeliosProfileManager.getInstance();
```

Thereafter, the app can load/store values, e.g., to check and load/store user UUID:

```
	// Get default preferences userId
        String userId = profileMgr.load(this, getString(R.string.setting_user_id), android.content.Context.MODE_PRIVATE);
        if (userId.isEmpty()) {
            userId = UUID.randomUUID().toString();
            profileMgr.store(this, getString(R.string.setting_user_id), userId, android.content.Context.MODE_PRIVATE);
            Log.d(TAG, "Initialization, userId not found, now set as " + userId);
        } else {
            Log.d(TAG, "Initialization, userId was set as " + userId);
        }
```

This uses the key eu.h2020.helios_social.USER_ID as set in:

`<string name="setting_user_id">eu.h2020.helios_social.USER_ID</string>`

The other values used in the current integration can be seen from
TestClient app's resources under strings.xml

Check out TestClient's MainActivity.checkUserAccount method for
further examples. For instance, saved home location is loaded when the
application is started by:

`profileMgr.load(context, "homelat");`

### HeliosUserData ###

Provides a cache file for the profile attributes.

For example, to get the UUID of the user:

`String mUserId = HeliosUserData.getInstance().getValue(getString(R.string.setting_user_id));`

### Testing ###

There is a test application (see app subdirectory) that also gives an
example of the API usage. The application can be used to run a series
of basic profile operations by clicking the floating action button.
There is also a small set of unit tests to test basic HeliosUserData
functionality.

### Future work ###

* The most common used profile attributes could be included in the
  library itself. Although, the profile manager requirement was to be
  general and it should be easy to extend in case new attributes are
  needed, therefore it implements a key-value structure at the moment.

## Multiproject dependencies ##

HELIOS software components are organized into different repositories
so that these components can be developed separately avoiding many
conflicts in code integration. However, the modules also depend on
each other.

`Profile` depends on the projects:

* HELIOS Security and Privacy API - https://github.com/helios-h2020/h.core-SecurityAndPrivacyManager

* HELIOS Messaging API - https://github.com/helios-h2020/h.core-Messaging

### How to configure the dependencies ###

To manage project dependencies developed by the consortium, the
approach proposed is to use a private Maven repository with Nexus.

To avoid clone all dependencies projects in local, to compile the
"father" project. Otherwise, a developer should have all the projects
locally to be able to compile. Using Nexus, the dependencies are
located in a remote repository, available to compile, as described in
the next section.  Also to improve the automation for deploy,
versioning and distribution of the project.

### How to use the HELIOS Nexus ###

Similar to other dependencies available in Maven Central, Google or
others repositories. In this case we specify the Nexus repository
provided by Atos:

```
https://builder.helios-social.eu/repository/helios-repository/
```

This URL makes the project dependencies available.

To access, we simply need credentials, that we will define locally in
the variables `heliosUser` and `heliosPassword`.

The `build.gradle` of the project define the Nexus repository and the
credential variables in this way:

```
repositories {
        ...
        maven {
            url "https://builder.helios-social.eu/repository/helios-repository/"
            credentials {
                username = heliosUser
                password = heliosPassword
            }
        }
    }
```

And the variables of Nexus's credentials are stored locally at
`~/.gradle/gradle.properties`:

```
heliosUser=username
heliosPassword=password
```
To request Nexus username and password, contact Atos (jordi.hernandezv@atos.net).

### How to use the dependencies ###

To use the dependency in `build.gradle` of the "father" project, you
should specify the last version available in Nexus, related to the
last Jenkins's deploy.  For example, to declare the dependency on the
security and messaging module and their respective versions:

```
implementation 'eu.h2020.helios_social.core.security:security:1.0.3'
implementation 'eu.h2020.helios_social.core.messaging:messaging:2.0.15'
```

If the software module wants to use the profile module then the following line should
be put to the module specific build.gradle file:

    implementation 'eu.h2020.helios_social.core.profile:profile:1.0.11

## Android Studio project structure ##

This Android Studio Arctic Fox 2020.3.1 Patch 2 project contains the
following components:

* app - Profile API test application

* doc - Additional documentation files

* lib - Profile API implementation


text:
# Virtual Intracranial Stenting Challenge 2011

Author: Arjan Geers<EMAIL_ADDRESS>

## About

This is a repository with Python scripts to reproduce some of the plots in:

Cito S, Geers AJ, Arroyo MP, Palero VR, Pallarés J, Vernet A, Blasco J, San Román L, Fu W, Qiao A, Janiga G, Miura Y, Ohta M, Mendina M, Usera G, and Frangi AF. Accuracy and Reproducibility of Patient-Specific Hemodynamics Models of Stented Intracranial Aneurysms: Report on the Virtual Intracranial Stenting Challenge 2011. Annals of Biomedical Engineering, 43(1):154–167, 2015.

## The Challenge

Since 2006, the yearly Virtual Intracranial Stenting Challenge (VISC) has been a unique platform evaluating the inter-group reproducibility of computational fluid dynamics (CFD) simulations of stented aneurysms.

The 2011 edition of VISC was organized by Salvatore Cito and Arjan Geers. Preliminary results were presented at the 8th International Interdisciplinary Cerebrovascular Symposium (ICS) 2011, Shanghai, China.

The subject of the challenge was an aneurysm located at the anterior communicating artery. This is the vascular geometry with labels for inlets/outlets and regions-of-interest:

![](figs/example/geometry.png?raw=true)

Challenge participants were invited to simulate the steady-state velocity field in the aneurysm assuming blood to be an incompressible Newtonian fluid and the vessel wall to be rigid with a no-slip boundary condition.

The velocity field had to be assessed for the untreated aneurysm (case 0) and for the aneurysm virtually treated with five different configurations of high-porosity stents (cases 1 to 5). The stent configurations were composed of open cell and closed cell stents, as can be seen in this image:

![](figs/example/stent_configurations.png?raw=true)

As input data, we provided the challenge participants with surface meshes of the vascular geometry and the deployed stents, blood properties, and flow rate boundary conditions for all inlets and outlets.

The simulated velocity field of case 0 was validated with particle imaging velocimetry (PIV) measurements.

For more details, please check the journal publication.

## Data

Three sets of data are available on FigShare:

1. [Dataset 1](http://dx.doi.org/10.6084/m9.figshare.1060443). Input data provided to the participants:
    * STL surface mesh (in mm) of vascular geometry
    * STL surface meshes (in mm) of deployed stent geometries
    * Image of vascular and stent geometries with labels for inlets/outlets and regions-of-interest
    * Instructions to challenge participants, including flow rate boundary conditions and blood properties
2. [Dataset 2](http://dx.doi.org/10.6084/m9.figshare.1060453). PIV dataset:
    * PIV dataset (in mm) stored in a vtkImageData object
3. [Dataset 3](http://dx.doi.org/10.6084/m9.figshare.1060464). CFD solutions from one of the participants (research group E):
    * CFD solutions of all cases stored in vtkUnstructuredGrid objects
    * Details on the mesh and CFD set-up

If you download the data directly from FigShare and wish to run the scripts, please copy Dataset 1 to `data/input`, Dataset 2 to `data/piv`, and Dataset 3 to `data/cfd`. The gz-files in `data/cfd` will need to be decompressed.

However, by far the easiest way to download the data is to run `code/download_data.py`, cross your fingers, and watch the data folder getting populated automatically.

## Instructions

To run the scripts, follow these instructions.

Clone the repository and cd into it:
```sh
git clone https://github.com/ajgeers/visc11
cd visc11
```

Download the data from FigShare:
```sh
python code/download_data.py
```

Run any of the other scripts to generate plots. For example,
```sh
python code/contourplot_xyplane.py
```

generates for each of the six cases and the piv image a velocity contourplot on the xy-plane and saves it in PDF format.

For case 1, these are the outputs of, from left to right, `code/streamplot_xyplane.py`, `code/contourplot_xyplane.py`, `code/contourplot_yzplane.py` and `code/lineplot_yaxis.py`:

![](figs/example/streamplot_xyplane.png?raw=true)
![](figs/example/contourplot_xyplane.png?raw=true)
![](figs/example/contourplot_yzplane.png?raw=true)
![](figs/example/lineplot_yaxis.png?raw=true)

Notes:
* Six research groups participated in the challenge. In the paper, we showed the results from all groups together in the plots generated with `code/lineplot_yaxis.py`.
* `code/streamplot_xyplane.py` takes relatively long to run.
* The data in `input/` is not needed for making the plots.

## Python environment

```sh
conda env create -n visc11 -f environment.yml
conda activate visc11
```

## License

BSD 2-Clause


text:
# Mutable Swapchain Format

This sample renders a rotating cube on the screen with a swapchain that is
created with a UNORM format and image views with a SRGB format. To enable the
creation of a swapchain with a mutable format the device extensions
`VK_KHR_maintenance2`, `VK_KHR_image_format_list`, and
`VK_KHR_swapchain_mutable_format` are requested. The creation of a swapchain
with a mutable format is controlled by providing a
`VkImageFormatListCreateInfoKHR` and setting the swapchain create info flag
`VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR`.


text:
---
hrs_structure:
  division: '1'
  volume: '2'
  title: '7'
  chapter: 87A
  section: 87A-24
type: hrs_section
tags:
  - Government
menu:
  hrs:
    identifier: HRS_0087A-0024
    parent: HRS0087A
    name: 87A-24 Other powers
weight: 40100
title: Other powers
full_title: 87A-24 Other powers
---
**§87A-24 Other powers.** In addition to the power to administer the fund, the board may:

(1) Collect, receive, deposit, and withdraw money on behalf of the fund;

(2) Invest moneys in the same manner specified in section 88-119;

(3) Hold, purchase, sell, assign, transfer, or dispose of any securities or other investments of the fund, as well as the proceeds of those investments and any money belonging to the fund;

(4) Appoint, and at pleasure dismiss, an administrator and other fund staff. The administrator and staff shall be exempt from chapter 76 and shall serve under and at the pleasure of the board;

(5) Make payments of periodic charges and pay for reasonable expenses incurred in carrying out the purposes of the fund;

(6) Contract for the performance of financial audits of the fund and claims audits of its insurance carriers;

(7) Retain auditors, actuaries, investment firms and managers, benefit plan consultants, or other professional advisors to carry out the purposes of this chapter, including the retaining of an actuary to determine the annual required public employer contribution for the separate trust fund established under section 87A-42;

(8) Establish health benefits plan and long-term care benefits plan rates that include administrative and other expenses necessary to effectuate the purposes of the fund; and

(9) Require any department, agency, or employee of the State or counties to furnish information to the board to carry out the purposes of this chapter. [L 2001, c 88, pt of §1; am L 2004, c 216, §15; am L 2013, c 268, §7; am L 2016, c 30, §2]

repository: SamMade/BlueAndKrabby

repo_name: SamMade/BlueAndKrabby


text:
# Symbols

- A new primitive type in ES6
- You can create your own symbols using var symbol = Symbol()
- You can add a description for debugging purposes, like Symbol('ponyfoo')
- Symbols are immutable and unique. Symbol(), Symbol(), Symbol('foo') and Symbol('foo') are all different
- Symbols are of type symbol, thus: typeof Symbol() === 'symbol'

## Symbol( )

Calling Symbol() or Symbol(description) will create a unique symbol that cannot be looked up globally. A Use case for Symbol() is to patch objects or namespaces from third parties with your own logic, but be confident that you won't collide with updates to that library.

## Symbol.for(key)

Symbol.for(key) will create a Symbol that is still immutable and unique, but can be looked up globally. Two identical calls to Symbol.for(key) will return the same Symbol instance. NOTE: This is not true for Symbol(description):

```
Symbol('foo') === Symbol('foo') // false
Symbol.for('foo') === Symbol('foo') // false
Symbol.for('foo') === Symbol.for('foo') // true
```

repository: juvoni/til

repo_name: juvoni/til


text:
operator-yank
===

This is plugin to yank text same as Vim default yank operator.
But this depends on [operator-user](https://github.com/kana/vim-operator-user).

Gary Bishop hacked it to copy the yanked text to the clipboard using OSC52.

Requirements
---

[operator-user](https://github.com/kana/vim-operator-user)

Usage
---

This plugin define no default key mappings.

So you need to define key mappings. Look at Settings.

Settings
---

You need map key to use this plugin.

This is example settings.

```vim
map y  <Plug>(operator-yank)
map Y  <Plug>(operator-yank)$
```

License
---

This plugin is distributed under MIT License.

repository: gbishop/vim-operator-yank

repo_name: gbishop/vim-operator-yank


text:
---
layout: post
title:      "Most Important Thing to Understand About Hashes"
date:       2018-03-11 00:44:00 +0000
permalink:  most_important_thing_to_understand_about_hashes
---

The most important thing to understand about hashes is that they store data in key-value pairs.

In an array, values are automatically stored and referenced by indices - 0, 1, 2, etc.

Hashes allow a programmer to create custom references - keys - in which to store data.

Unlike array indices, which are always consecutive integers starting from 0, keys are either strings or symbols.

extension: markdown


text:
# tvision
Fork of Sergio Sigala's Turbo Vision Port, fixed to build modern autotools.

# Cygwin
If the sources had been checked out accidentially with dos file endings convert them first (set the core.autocrlf setting to false for this project):
```
find . -name '*' | xargs dos2unix
```
The ncurses library headers have to be installed. Additionally there were problems with the installed libtool version and the project finally build successfully with the 3 commands:
```
autoreconf --force --install
./configure
make
```

repository: t-h-a-l-i-s/tvision

repo_name: t-h-a-l-i-s/tvision


text:
# Basic Configuration Exercise 1

1. Write a Playbook that contains configures a vlan (pick any vlan between 3000 and 4000) on all devices in the arista group.

2. Write a second task that uses the "eos_vlan" module to accomplish configuring the same vlan.

3. Ensure that after the vlan has been created, running this Playbook shows no changes occurred.

repository: twin-bridges/ansible-ons

repo_name: twin-bridges/ansible-ons


text:
- Simplicity - users have enough on their plate already
- Consistency - in naming, fonts, colours, positioning of nav items etc.
- Navigability
    - User should be able to leave any area and find their way back
    - The options they need should be close to hand
- If icons are used in place of text they must be unambiguous
- Tone of writing should be warm and personal e.g. Your journey, My photos
- Errors and modal dialogs appear as overlays
- Fonts
    - System text: Roboto (probably)
    - Page text: Short Stack
- Colour scheme - existing brand colours
    - #0FC6CC Prepareme Turquoise (primary)
    - #FBB03B Prepareme Yellow
    - #CCCCCC Prepareme Light Grey
    - #FFFFFF Pure White
    - #000000 Pure Black
- White backgrounds should have black text and icons
- ~~Primary backgrounds should have white text and icons~~
- Mobile first design,
- Material UI for grid, UI widgets and base theme
- Styled components for customising MUI components and non-MUI components


text:
phaser-game
===========

a study game

please note this is development version

how to initialize developement environment
---

before init, please install nodejs and grunt-cli

```shell
npm install -g grunt-cli
```

then open your shell and type:

```shell
npm install
```

how to play
---

type:
```
grunt
```

then open your browser


text:
# boreutils

An implementation of some of the [utilities](https://pubs.opengroup.org/onlinepubs/9699919799/idx/utilities.html) specified in [POSIX.1-2017](https://pubs.opengroup.org/onlinepubs/9699919799/toc.htm).

## Excluded utilities

Boreutils focuses on non-optional utilities.
Many POSIX utility categories and XSI (X/Open Systems Interfaces) utilities are excluded.

Things explicitly excluded include:

- Things that make more sense as shell builtins, including:
  * Things that are only really usable in a shell: `cd`, `hash`, `read`, etc.
  * Things related to job control: `bg`, `fg`, `jobs`, etc.
- Things used exclusively for printing: `lp`, etc.
- The following [Margin Codes](https://pubs.opengroup.org/onlinepubs/9699919799/help/codes.html):
  * `CD`: C-Language Development Utilities
  * `FD`: FORTRAN Development Utilities
  * `FR`: FORTRAN Runtime Utilities
  * `OB`: Obsolescent
  * `SD`: Software Development Utilities
  * `UU`: UUCP Utilities
- Things that are very heavily influenced by software not in Boreutils, including:
  * Things that have terminal-specific behavior, like `tput`.

Things not excluded, but prone to be put off forever include:

- Things where the standard doesn't provide enough information:
  * `mesg`: "The mechanism by which the message status of the terminal is changed is unspecified"
- Things where there's no standard for the underlying functionality:
  * `ps`: On Linux, you read /proc. On BSD, you use `kvm_getproc*()`. Elsewhere?
- Obscenely complex things, such as those involving creating archives:
  * `pax`

## Utilities, and current status

Below is the list of [POSIX.1-2017 utilities](https://pubs.opengroup.org/onlinepubs/9699919799/idx/utilities.html) that are planned to be implemented.

Utilities that are checked off have been implemented. Partial implementations
have notes explaining what is missing and a link to GitHub issues.

- [ ] at
- [ ] awk
- [x] basename
- [ ] batch
- [ ] bc
- [x] cal (August 1752 and earlier is broken. [GH#4](https://github.com/duckinator/boreutils/issues/4))
- [x] cat
- [ ] chgrp
- [ ] chmod
- [ ] chown
- [ ] cksum
- [ ] cmp
- [ ] comm
- [ ] cp
- [ ] crontab
- [ ] csplit
- [ ] cut
- [x] date
- [ ] dd
- [ ] df
- [ ] diff
- [x] dirname
- [ ] du
- [x] echo
- [ ] ed
- [x] env
- [ ] ex
- [ ] expand
- [ ] expr
- [x] false
- [ ] file
- [ ] find
- [ ] fold
- [ ] gencat
- [ ] getconf
- [ ] getopts
- [ ] grep
- [x] head
- [ ] iconv
- [x] id
- [ ] join
- [x] kill (`kill -l EXIT_STATUS` is unimplemented. [GH#7](https://github.com/duckinator/boreutils/issues/7))
- [x] link
- [ ] ln
- [ ] locale
- [ ] localedef
- [ ] logger
- [ ] logname
- [ ] ls
- [ ] m4
- [ ] mailx
- [ ] make
- [x] man (It's not very robust, and doesn't support `-k`. [GH#8](https://github.com/duckinator/boreutils/issues/8))
- [x] mkdir
- [ ] mkfifo
- [ ] more
- [ ] mv
- [ ] newgrp
- [ ] nice
- [ ] nl
- [ ] nohup
- [ ] od
- [ ] paste
- [ ] patch
- [ ] pathchk
- [ ] pax
- [ ] pr
- [ ] printf
- [ ] ps
- [x] pwd
- [ ] renice
- [x] rm
- [x] rmdir
- [ ] sed
- [ ] sh
- [x] sleep
- [ ] sort
- [ ] split
- [ ] strings
- [ ] stty
- [ ] tabs
- [x] tail
- [ ] talk
- [ ] tee
- [ ] test
- [ ] time
- [ ] touch
- [ ] tr
- [x] true
- [ ] tsort
- [x] tty
- [ ] umask
- [x] uname
- [ ] unexpand
- [ ] uniq
- [x] unlink
- [ ] uudecode
- [ ] uuencode
- [ ] vi
- [ ] wc
- [ ] xargs

Here are non-POSIX.1-2017 utilities which are provided:

- [x] dir (an extremely basic `ls` alternative)
- [x] ish (an extremely basic shell; not POSIX-compliant)
- [x] which (no standard)
- [x] whoami (no standard)
- [x] yes (no standard)

repository: thefresia/boreutils

branch_name: refs/heads/main

repo_name: thefresia/boreutils


text:
# What's New

## gatsby-theme-ocular

gatsby now supports themes and the ocular documentation generator has been repackaged as `gatsby-theme-ocular`, which is easier to use and maintain.

Release details are available in the [CHANGELOG](https://github.com/uber-web/ocular/blob/master/modules/gatsby-theme-ocular/CHANGELOG.md)

## ocular-gatsby (Deprecated)

Now that gatsby supports themes, development has moved to `gatsby-theme-ocular`. No further fixes will be made to `ocular-gatsby`

repository: uber-web/ocular

repo_name: uber-web/ocular


text:
# Prometheus DHCP service discovery

Generate Prometheus scrape configurations for multiple targets and jobs by parsing the ISC DHCP lease file. Supports lease filtering on hostname and MAC address.

```
usage: dhcpd-service-discovery.py [-h] [-j {name:port} [{name:port} ...]] [-l PATH] [-o PATH] [-m MAC [MAC ...]]
                                  [-n HOSTNAME [HOSTNAME ...]] [-p]

optional arguments:
  -h, --help            show this help message and exit
  -j {name:port} [{name:port} ...], --job {name:port} [{name:port} ...]
                        Jobs to configure, accepts multiple values (e.g. node:9100)
  -l PATH, --leases PATH
                        Path to dhcpd.leases file (default: /var/lib/dhcp/dhcpd.leases)
  -o PATH, --output PATH
                        Path to targets file (default: /etc/prometheus/targets.json)(- for stdout)
  -m MAC [MAC ...], --mac MAC [MAC ...]
                        Whitelist MAC address (note: accepts regex)
  -n HOSTNAME [HOSTNAME ...], --hostname HOSTNAME [HOSTNAME ...]
                        Whitelist hostname (note: accepts regex)
  -p, --print           Print active DHCP leases and quit.
```

## Dependencies

https://github.com/MartijnBraam/python-isc-dhcp-leases


text:
# city_explorer_api

# Project Name

**Author**: Ameilia Valdes & Simon Panek

**Version**: 1.0.2

## Overview
This app pulls in location data and weather data for a given city from other API's and displays them for the user.

## Getting Started
If the app is run in the web browser no additional local resources will be required.

## Architecture
This app is supported using Node.js and is deployed on Heroku.

## Change Log
1.0.1 - App now pulls location data dynamically based on city name. Also populates weather forecast and hiking options based on the location from outside API's.
1.0.2 - added a database to store previously searched location data.
## Credits and Collaborations
Thanks to Bade, Skyler, Chance & all other TA's!
-->

### Number and name of feature: Location Feature

Estimate of time needed to complete: 20 mins
Start time: 12:40

Finish time: 1:15

Actual time needed to complete: 35mins

### Number and name of feature: Weather Feature

Estimate of time needed to complete: 20 mins

Start time: 1:15

Finish time: 2:10

Actual time needed to complete: 55mins

### Number and name of feature: 505 error

Estimate of time needed to complete: 1 hour

Start time: 2:20

Finish time: 3:30

Actual time needed to complete: 1:10

### Number and name of feature: .map() for Weather data

Estimate of time needed to complete: 45 minutes

Start time: 1:20pm

Finish time: 2:25

Actual time needed to complete: 65 min

### Number and name of feature: Latitude and Longitude from Location Name

Estimate of time needed to complete: 20 min

Start time: 2:30 pm

Finish time: 2:52 pm

Actual time needed to complete: 22 min

### Number and name of feature: Weather info from Location

Estimate of time needed to complete: 80 min

Start time: 2:30pm

Finish time: 3:41pm

Actual time needed to complete: 71 min

### Number and name of feature: Trails from Location Name

Estimate of time needed to complete: 80 min

Start time: 3:42 pm

Finish time: 4:02 pm

Actual time needed to complete: 20 min

### Number and name of feature: Database

Estimate of time needed to complete: 60 min

Start time: 2:02 pm

Finish time: 3:00 pm

Actual time needed to complete: 58 min

### Number and name of feature: Server

Estimate of time needed to complete: 60 min

Start time: 3:00 pm

Finish time: 4:29 pm

Actual time needed to complete: 89 min

### Number and name of feature: Deploy

Estimate of time needed to complete: 30 min

Start time: 4:29 pm

Finish time: 4:38 pm

Actual time needed to complete: 9 min

### Number and name of feature: Movies

Estimate of time needed to complete: 60 min

Start time: 2:00 pm

Finish time: 2:45 pm

Actual time needed to complete: 45 min

### Number and name of feature: Yelp

Estimate of time needed to complete: 60 min

Start time: 2:45 pm

Finish time: 3:44 pm

Actual time needed to complete: 59 min


text:
[![DOI](https://zenodo.org/badge/428771973.svg)](https://zenodo.org/badge/latestdoi/428771973)

# AutoBEM-DynamicArchetypes
Automatic Building Energy Modeling (AutoBEM, https://bit.ly/AutoBEM) has been used to create an OpenStudio and EnergyPlus building energy model of 122.9 million U.S. buildings (https://bit.ly/ModelAmerica). Simulating and analyzing a model of every building for large areas (e.g. cities) is often not feasible. This dynamic archetyping capability uses a representative building and calculates a floor-space multiplier that allows millions of buildings to be represented by less than 100 buildings.

This script (WRF_Archetypes_Parallel.py) calculates these building archetypes for each of the grid cells from a Weather Research and Forecasting (WRF) model in a parallel fashion. The script works by looping through each of the grid cells in the shapefile in parallel, spatially joining the building metadata table to each grid cell, aggregating relevant archetypes and calculating necessary statistics related to area and number of buildings in each cell. The output is a table (.csv) in which each row is an archetype building with properties about that building as well as statistics that relate that building to the total cell (such as an area multiplier).

The following inputs are required:

1. WRF zone shapefile (.shp) (wrf-grids-origin_Vegas_Select_100.geojson)
2. The projection of the shapefile ("EPSG:XXXX")
3. Input table containing building metadata for area corresponding to shapefile (.csv) (https://zenodo.org/record/4552901#.YZQEotDMJPY - ClarkCounty2.csv)
4. The number of cores that will be parallelized (integer)
5. The output file name for the archetype table (.csv)

Sample command line inputs:

python3 ~/WRF_Archetypes_Parallel.py -i ~/wrf-grids-origin_Vegas_Select_100.geojson -c ~/ClarkCounty2.csv -o ~/OutputArchetypes.csv -j 72 -e EPSG:4326

**Using Geopandas Version 0.9.0**

repository: ORNL-BTRIC/AutoBEM-DynamicArchetypes

repo_name: ORNL-BTRIC/AutoBEM-DynamicArchetypes


text:
## Validate data easily with JSON Schema
Originally published: 2015-12-06 21:23:47
Last updated: 2015-12-06 21:23:48
Author: Vasudev Ram

This recipe shows how to use the jsonschema Python library, which implements the JSON Schema specification, to easily validate your Python data. It sends good output to stdout and bad output to stderr, for demo purposes.

jsonschema Python library: https://pypi.python.org/pypi/jsonschema

JSON Schema: http://json-schema.org/

gha_language: Python


text:
# Game : CityBuilder
Small Exercise in unity*
<<<<<<< HEAD

## Git : [GitHub Link] (https://github*com/rohitwesley/CityBuilder*git)
=======
>>>>>>> master

## Git :
[GitHub Link](https://github.com/rohitwesley/CityBuilder.git)
## OS Platform : Mac/Windows

## Unity : Unity 2019*2*8f1

## Inputs :
* WASD - move player on TileMap
* Left Mouse - Create Unit at given point using a menu of agent types

## Features :
* Tile Map
* Move Player on TileMap
* Create, Select and View Status, Edit, Delete(CRUD) agents on TileMap
* Agents move on tile map
<<<<<<< HEAD
⋅⋅* Pawn moves from one waypoint to the next in loop searching for new waypoint every nth sec
=======
⋅⋅⋅* Pawn moves from one waypoint to the next in loop searching for new waypoint every nth sec
>>>>>>> master
* Change time of day

## WIP :
* Reset the scene when pressing the reset button

## TODO Prototype:
* Reset the scene when pressing the reset button
* Change time of Day with a slider

## TODO Final:
* Higlight Grid Tile when pointed at*
* Select Grid Tile using "Menu 1" (Shows Radial UI Menu With Types Of Buildings)*
* Place Selected Building on Tile*
* Residential spawns Pawns that move to different buildings and then get Destroyed*
* Select Reset using "Menu 2" (Shows Radial UI Menu with Reset,Day N Night Slider) to clear city*
* Select Slider using "Menu 2" (Shows Radial UI Menu with Reset,Day N Night Slider) to change time of day in city*

repository: rohitwesley/CityBuilder

repo_name: rohitwesley/CityBuilder


text:
#STPTransitions

> Unified, easy API for custom iOS view controller transitioning.

Perhaps you watched the [2013 WWDC talk](http://asciiwwdc.com/2013/sessions/218) or read the [slightly](https://developer.apple.com/library/ios/documentation/uikit/reference/UIViewControllerAnimatedTransitioning_Protocol/Reference/Reference.html) [spread-out](https://developer.apple.com/library/ios/documentation/uikit/reference/UIViewController_Class/Reference/Reference.html#//apple_ref/occ/instm/UIViewController/transitionFromViewController:toViewController:duration:options:animations:completion:) [documentation](https://developer.apple.com/library/ios/documentation/uikit/reference/UIViewControllerInteractiveTransitioning_protocol/Reference/Reference.html#//apple_ref/occ/intf/UIViewControllerInteractiveTransitioning) on how to use custom transitions between child view controllers, modal view controllers and in a navigation controller. Couple of minutes in, you're wandering in Protocolandia and you're lost. We don't blame you.

## Installation

`pod 'STPTransitions'` (via [CocoaPods](http://cocoapods.org))

## Features (TL;DR)

* Child view controller transitions
* Modal view controller transitions (+ fix for landscape)
* Navigation controller transitions
* Unified, simple API

In the works:

* Full interactive transition support

## Usage

First import the library's header:

```
#import <STPTransitions.h>
```

### Quick start: STPBlockTransition

With `STPBlockTransition`, you can quickly create in-line transitions

```
STPTransition *snazzyTransition = [STPTransition transitionWithAnimation:
 ^(UIView *fromView,
   UIView *toView,
   UIView *containerView,
   void (^executeOnCompletion)(BOOL finished)) {
     // Your fabulous animations go here
}];
```
Note: You have two important responsibilities:

 * `fromView` **is** a subview of `containerView`, `toView` is **not**. Add it when appropriate.
 * Execute `executeOnCompletion` when the animation is completed (at the end of its completion block).

### Using transition: navigation controller

To set up, assign the `STPTransitionCenter` singleton as navigation controller's delegate:

```
navigationController.delegate = [STPTransitionCenter sharedInstance];
```

Now simply push and pop view controllers using:

```
[self.navigationController pushViewController:viewController
                              usingTransition:snazzyTransition];
// and
[self.navigationController popViewControllerUsingTransition:transition];
```

### Using transition: child controllers

No setup is needed. In the parent controller, switch between two child controllers using:

```
[self transitionFromViewController:oldChildViewController
                  toViewController:newChildViewController
                   usingTransition:snazzyTransition];
```
Note: This transition currently cannot be interactive. If you'd like this feature, voice your opinion in the Issues.

### Using transition: modal controller

To set up, assign the `STPTransitionCenter` singleton as presenting controller's delegate:

```
self.transitioningDelegate = [STPTransitionCenter sharedInstance];
```

Now simply present and dismiss view controllers using:

```
[self presentViewController:viewController
            usingTransition:snazzyTransition
                 completion:completion];
// and
[self dismissViewControllerUsingTransition:snazzyTransition
                                completion:(void (^)(void))completion];
```

### Proper usage: Subclassing STPTransition

To maintain thin view controllers and a nicely separated codebase, you probably don't want to keep your transition animation code in the view controller itself. It also allows for the transition to be reused. You achieve both of these goals by subclassing `STPTransition`.

See the [example project](Example) for a hands-on code example.

### Reverse transitions

When pushing or presenting a view controller, you can specify which transition should happen when the returning (i.e. pop or dismiss) operation takes place. To do that, simply assign the transition object to be used to `reverseTransition`.

This greatly helps decoupling, because the pushed/presented controller doesn't have to know anything about how it's being shown.

_Pro tip:_ Just assign `reverseTransition` to be a new instance of the same class you just created for the push/present. See below on how to easily handle both animations in one class.

### Modal transitions in landscape orientation

As of iOS 7.0.2, custom modal transitions in landscape orientation are not very usable, because the views iOS gives you have all kinds of messed up frames and transforms. STPTransitions attempts to solve this for you, providing you a view in the orientation you'd expect. This has been tested and works for iPad full-screen landscape custom modals.

### Regular and reverse implementation in one class

Often, you don't want to have two `STPTransition` subclasses for the same type of animation, i.e. one for going forward, and one for going back. When going back – popping or dismissing a controller – the transition instance automatically gets assigned `YES` for `isReversed`.

_Pro tip_: Reuse code and handle both forward and backward transitions in the same class. Usually it means having `if/else` conditionals on `isReversed`.

### Triggering by a gesture recognizer

A transition can have a gesture recognizer assigned. The transition gets _automatically_ kicked off when the recognizer's gesture is detected.

Note: This does **not** mean the transition is interactive (e.g. follows users finger), although it **can** be.

### Interactive transitions

TODO: Interactive transitions aren't fully supported yet.

1. Set the `interactive` property to `YES`.
2. Assign `gestureRecognizer` that is going to track the progress.
3. Implement `interactiveGesturePercentageCompletionForPoint:` in your subclass.

Note: An interactive transition doesn't necessarily need to be _triggered_ interactively, e.g. it can be triggered by a button and happen non-interactively. The `wasTriggeredInteractively` property informs about the way it was triggered.

## Included transitions

If you'd like the library to include some configurable, often used transitions by default, voice your opinion in the Issues. Contributions are also welcome.

## FAQ

**Q: I need for my `UINavigationController` to have my own delegate. What do I do?**
A: Subclass your delegate from `STPTransitionCenter` and use your own instance instead of the default center. You're responsible for keeping that object around, as you're not using the singleton. Make sure you call `super` in any delegate methods that are implemented by the center.

---

Created by [Stepan Hruda](https://twitter.com/stepanhruda). If you follow him on Twitter, he's gonna have a good time.

Thanks goes to [Josh Vickery](https://twitter.com/vickeryj) and [ShopKeep POS](http://www.shopkeep.com) for contributions and feedback.

Released under [MIT License](LICENSE).

repository: shopkeep/STPTransitions

gha_language: Objective-C

repo_name: shopkeep/STPTransitions


text:
# Vue build tutorial examples

These are examples from each part of my tutorial on setting up a Vue.js build.
The web app we are making is a simple application for displaying a message and
picking which color to display it in.

Under each folder, you can find an example from the tutorial. To try it out, go
into that folder, and you will find instructions on how to use the app in the
README file.

repository: andyhaskell/vue-build-tutorial

repo_name: andyhaskell/vue-build-tutorial


text:
# New Relic Servers monitoring

Docker container for running the New Relic monitoring daemon for servers.

[https://docs.newrelic.com/docs/servers/new-relic-servers-linux/getting-started/new-relic-servers-linux]()

**Note:** Even though this will report uptime, as of now it won't give you accurate host statistics
because there isn't yet a way to use a custom `/proc` location to bind-mount host data. Without it,
this daemon will only report usage from within this container, which is not very useful. Let's hope
New Relic fixes this soon.

## Usage

Just set your license key using an environment variable and don't forget the hostname that
you would like to show in your New Relic dashboard.

    docker run -d -e LICENSE_KEY=<your-license> -h `hostname` helder/newrelic-sysmond

You can also use the following environment variables:

* `LOG_LEVEL` (default: info)
* `LOG_FILE` (default: /dev/stdout)

### Unit for CoreOS

If you're using CoreOS add a systemd unit:

    # newrelic-sysmond.service

    [Unit]
    Description=New Relic Server monitoring
    After=docker.service
    Requires=docker.service

    [Service]
    Restart=always
    TimeoutStartSec=0
    ExecStartPre=/usr/bin/docker pull helder/newrelic-sysmond
    ExecStartPre=-/usr/bin/docker kill newrelic-sysmond
    ExecStartPre=-/usr/bin/docker rm -v newrelic-sysmond
    ExecStart=/usr/bin/docker run -e LICENSE_KEY=<your-license> -h %H --name newrelic-sysmond helder/newrelic-sysmond
    ExecStop=/usr/bin/docker stop newrelic-sysmond

    [X-Fleet]
    Global=true

And run it with fleet:

    fleetctl start newrelic-sysmond.service

repository: helderco/docker-newrelic

repo_name: helderco/docker-newrelic


text:
# go-template

[![Go Report Card](https://goreportcard.com/badge/github.com/sascha-andres/go-template)](https://goreportcard.com/report/github.com/sascha-andres/go-template) [![codebeat badge](https://codebeat.co/badges/530c668a-42cb-41f5-a8e5-5284f606aa5e)](https://codebeat.co/projects/github-com-sascha-andres-go-template-master) [![Maintainability](https://api.codeclimate.com/v1/badges/f3fd3deb5a43e8acf536/maintainability)](https://codeclimate.com/github/sascha-andres/go-template/maintainability) [![CodeFactor](https://www.codefactor.io/repository/github/sascha-andres/go-template/badge)](https://www.codefactor.io/repository/github/sascha-andres/go-template)

Create go projects from templates

## Concept

go-template stores templates locally by cloning them from a git repository. While not necessary, this is required to use management commands.

Each template contains a `.go-template.yml` which contains information like the name of the template, homepage, etc and metadata required to apply the template.

Cloning of the repositories is done by calls to git, so in order to have the management command working, your git installation has to be configured correctly.

## Installation

### Source code

    go get livingit.de/code/go-template

## Configuration

There is one global configuration, the storage. It is a directorty where the templates are stored and defaults to `/.go-template`. You can override it using the commandline, a `~/.go-template.yml` containing the storage setting.

## .go-template.yml

Placed in the root of the template repository this file enables go-template to use the repository as a template

    project:
      name: "go-rest"                                                    # Name your template
      description: "rest service implementation inspired by Mat Ryer"    # A longer description
      author: "Sascha Andres"                                            # Your name or handle
      repository: "https://github.com/sascha-andres/go-rest"             # homepage/repository

    transformation:
      templates:                                                         # List all files that are based on Go templates
        - README.md
      excluded-files:                                                    # List all files that shall not be part of new project
        - ".go-template.yml"
      renames:                                                           # rename files/folders
        - from: "go-rest"
          to: "{{ .Name }}"
      replacements:                                                      # Replace content in files, templates will not be treated
        - from: "go_rest"
          to: "{{ .Name }}"
        - from: "github.com/sascha-andres/go-rest/go-rest/cmd"
          to: "{{ index .Arguments \"Namespace\" }}/{{ .Name }}/{{ .Name }}/cmd"
        - from: "github.com/sascha-andres/go-rest"
          to: "{{ index .Arguments \"Namespace\" }}/{{ .Name }}"
        - from: "go-rest"
          to: "{{ .Name }}"

    git: true                                                            # Initialize a git repository for new project

    arguments:                                                           # List of arguments required to run template
      - Namespace

## Usage

### Repository management

#### Add a repository

    go-template repo add --url <git-url>

#### Update all repositories

Iterate over all local repositories and issue a `git pull`

    go-template repo update

#### Update a repository

Issue a `git pull` for a specific repository

    go-template repo update --limit-to <name>

#### List all local repositories

Print out a tabular list of repositories installed locally

    go-template repo list

#### Info for a repository

Print out information for a specific repository. Useful to learn about arguments required to run the template

    go-template repo info --name <name>

### Apply

    go-template new --template <name> --name <project-name> --arguments [key=value],[key=value],...

Providing an argument more than one time will be considered an error

## Template repositories

### https://github.com/sascha-andres/go-rest

A rest service based on gin with prometheus metrics

## Acknowledgements

Using code from https://gist.github.com/r0l1/92462b38df26839a3ca324697c8cba04

## History

|Version|Description|
|---|---|
|1.0.2|- remove quotes around commit messages|
||- version info|
|1.0.1|add version command|
|1.0.0|switch to using go modules|
|0.3.4|code improvements|
|0.3.3|license information|
|0.3.2|add goreleaser configuration|
|0.3.1|remove some old url references|
| |update readme for binary distribution without go get|
|0.3.0|add vanity url|
|0.2.1|add badges to README|
|0.2.0|add vendoring|
| |add explicit templates|
| |add .go-template.yml description|
|0.1.0|initial version|

repository: sascha-andres/go-template

gha_language: Go

repo_name: sascha-andres/go-template


text:
# UBC API [![Build Status](https://travis-ci.org/arashout/ubcapi.svg?branch=master)](https://travis-ci.org/arashout/ubcapi)
## What it does:
Beautifies the lacking unofficial UBC transcript with extra information and better formatting.

## How it does this:
It does this in several ways:
1. Adding a course names columns
2. Removing unnecessary widgets
3. Spacing items out better and increasing the width of the table
4. Allow you to manually edit course names
5. Optionally allow you to remove unnecessary columns + rows

## Instructions

1. There's a link on [**this page**](http://arashout.site/posts/improved-ubc-transcript) that you should drag onto your bookmarks bar

2. Go to your [**Grades Summary**](https://ssc.adm.ubc.ca/sscportal/servlets/SRVSSCFramework?function=SessGradeRpt) page.

3. Click the bookmark link to run!

## Output

The code gets rid of the extra tabs/average calculator app, spaces things out a little better, and aligns the table to the header.

![After Transcript Example](./examples/After.png "After Transcript Example")

## Before Picture

This is what the transcript looked like before
![Before Transcript Example](./examples/Before.png "Before Transcript Example")

## How it works:
This application is split into 2 parts the [the bookmarklet](#Bookmarklet) and [the server](#The Server)

### Bookmarklet
- The bookmarklet is JavaScript code that runs on the user's browser to:
1. Prompts the user for input regarding what features to remove
2. Formats the page by removing unnecessary features
3. Make an GET request to the server to retrieve course names for the course codes on the grades page
4. Populates the new column called 'Course Names'

### The Server
1. Respond to GET requests from client

## Credits:
- [crclayton](https://github.com/crclayton) originally created the bookmarklet that formatted the transcript, I'm simply building off of it.

repository: LynxHack/ubcapi

repo_name: LynxHack/ubcapi


text:
Welcome to iss-locator 👋

> App that shows the current location of the International Space Station on a map. Uses fetch to get the station's location and the google map's api to mark it on a map. It also fetches and displays the number of humans currently in space as well as their names and the craft they are on.

### 🏠 [Homepage](https://github.com/ianwhiscombe/iss-locator)

### ✨ [Demo](http://iss-locator-app.surge.sh)

## Screenshot

![CleanShot 2020-08-19 at 14 40 44@2x](https://user-images.githubusercontent.com/40146191/90642209-05153080-e22a-11ea-8e6f-4b0e7b0e338e.png)

## Details

While building this app I've used the following languages:

* HTML
* CSS
* JavaScript

Amongst others, I focused on showing an understanding of these concepts:

* Using Bootstrap to style the app.
* Handling multiple API calls.
* Using fetch.
* Using promises to perform asynchronous tasks.
* Handling the Date object to display a live clock in the final app.

## Author

👤 **Ian Whiscombe**

* Website: www.ianwhiscombe.com
* Twitter: [@i4nw](https://twitter.com/i4nw)
* Github: [@ianwhiscombe](https://github.com/ianwhiscombe)
* LinkedIn: [@ian-whiscombe](https://linkedin.com/in/ian-whiscombe)

## Show your support

Give a ⭐ if this project helped you!

***
_This README was generated with ❤ by [readme-md-generator](https://github.com/kefranabg/readme-md-generator)_

repository: ianwhiscombe/iss-locator

repo_name: ianwhiscombe/iss-locator


text:
# RegexToolkit

This is a Java library for regular expressions and finite automata.
It includes a few applications that are useful for teaching
courses (see **User Interface** below).

It started out as an attempt to write a Java clone of RegeXeX:

http://sourceforge.net/projects/regexex/

http://dl.acm.org/citation.cfm?doid=1227310.1227462

I got as far as parsing regular expressions, converting them to finite
automata, and checking their equivalence: this is pretty useful for
grading regular expression assignments, since you can create
canonical solutions and then check students' regular expressions
against them.  Like RegeXeX, when regular expressions don't match
it will construct examples of strings that should be generated but
aren't, and strings that shouldn't be generated but are.

Unlike RegeXeX, there is no GUI, but I might get around to adding one
at some point.

*Update*: As of 14-Sep-2017, there is support for reading finite
automata from [JFLAP](http://www.jflap.org/) files, and the `gradefa`
command can be used to check a student's finite automaton against
a solution.

## Building it

There is an Ant build file (**build.xml**).  Run the command `ant jar` to build **regexToolkit.jar**.

## User Interface

To run the program interactively, run

```bash
java -jar regexToolkit.jar command
```

where `command` is one of the following commands:

* `help`: Prints a usage summary.
* `check`: Allows the user to enter a regular expression
  and example strings.  For each string, prints **ACCEPT** or
  **REJECT** depending on whether it is or isn't in the language
  generated by the regular expression.  This is useful for students
  to use to test their regular expressions.
* `equiv`: Allows the user to compare
  two regular expressions to see if the are equivalent.
  If they are not, generates example strings in the
  set differences between them.  (I.e., strings in A but not in B,
  and strings in B but not in A.)
* `batchequiv`: Like `equiv`, but allows comparing multiple
  regular expressions to a single master regular expression.
* `grade`: Takes a solution file and a student file, each of
  which is a text file with one regular expression per line.
  Checks the equivalence of each pair of regular expressions
  and prints out a message stating whether they are equivalent,
  and if not, produces example strings illustrating the differences
  in the generated languages.  This is nice for grading
  an entire assignment (consisting of multiple regular expression
  problems.)
* `gradefa`: Takes a student finite automaton and a solution finite
  automaton (both read from [JFLAP](http://www.jflap.org/) files)
  and determines whether or not they are equivalent.  Prints
  examples of incorrectly accepted or rejected strings in the case
  the student's automaton is not equivalent to the solution.

There is some other useful stuff if you poke around a bit.

The code is free software, distributed under the terms of the
[MIT license](http://opensource.org/licenses/MIT).

Feel free to email me if you have any feedback, and I hope you find this
stuff useful!

David Hovemeyer<EMAIL_ADDRESS>

repository: daveho/RegexToolkit

repo_name: daveho/RegexToolkit


text:
# Golang NanoPoW

NanoPoW is an implementation of the proof-of-work used by Nano. That supports CPU and GPU (currently only OpenCL).

## Usage

```golang
func main() {
    nanopow.GenerateWork([]byte{/** PREVIOUS HASH **/}, nanopow.V1BaseDifficult)
}
```

### CPU

By default, we always uses CPU. If GPU is available, it will use CPU and GPU, combined.

### GPU

By default, we don't support GPU. You need to enable it using the "build tags", when build use:

```bash
go build -tags cl
```

Currently the only available option is OpenCL ("cl" tag).

## "Benchmarks"

I don't have an huge amount of data to compare and limited devices to test against. Some devices doesn't supports OpenCL. All times are using the V1 difficulty.

| Device | OS | CPU-Only | CPU + OpenCL
| ------------- |  ------------- | ------------- |------------- |
| Samsung Galaxy S20+  | Android | ~9.62 seg  | _Untested_ |
| Blackberry KeyOne  | Android |  ~36.7 seg | _Untested_ |
|  |  | |
| R9 3900X + RX 5700XT | Windows | ~0.66 seg | ~0.27 seg |

## Limitations

#### Support OpenGL, OpenGLES or Vulkan:

Currently we only support OpenCL, which is not natively supported by some devices. I have some plans to add some support for OpenGL, OpenGLES or Vulkan. Seems that Vulkan Compute, if possible, is the best solution since it's compatible with Windows, Linux and Android.

#### Support multi-GPU:

Currently only one GPU is supported, but it can be easily fixed, but I don't have a multi-GPU setup to be able to test. :(

## Contributing
Pull requests are welcome.

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

repository: jserv/nanopow

repo_name: jserv/nanopow


text:
# A Toolkit for Fast Morphosyntactic Evaluation
This toolkit performs fast evaluation on two morphosyntactic evaluation tasks:
- Marvin and Linzen, *"[Targeted syntactic evaluation of language models](https://www.aclweb.org/anthology/D18-1151)"*, EMNLP 2018
- Gulordava et al., *"[Colorless green recurrent networks dream hierarchically](https://www.aclweb.org/anthology/N18-1108.pdf)"*, NAACL 2018

It takes **only ~3 minutes** to evaluate a language model on all the tasks of targetd syntactic evaluation.

## Dependencies
Python 3.7

SpaCy

regex

PyTorch >= 1.2.0

transformers == 2.0.0 (for the evaluation of a pretrained language model)

## Usage

### Example (evaluating GPT-2)
```
git clone --recursive https://github.com/ExplorerFreda/SyntaxEval.git
python filter_datasets.py  # preprocessing
python main.py --lm-name gpt2 --batch-size 32 --load-evaluator-path ./data/common evaluators.pt
```

For detailed or customized evaluation, please refer to the arguments in `main.py`.

To evaluate a custom language model, you will need a language model class with a member function `prob_score`.

The `prob_score` function takes a batch of strings (i.e., untokenized sentences) as input, and outputs a list of float indicating the "probability score" of each sentence according to the language model.

### Definition: Probability Scores
Let *P(s; LM)* denote the probability of sentence *s* given by the language model *LM*. Then a function *f(s)* is a valid probability score function using this language model, if and only if the following statement is true:

For any two sentences *s1* and *s2*, if *P(s1; LM) >= P(s2; LM)*, then *f(s1) >= f(s2)*.

For example, log probability is a valid probability score function.

Note: the definition above implies that same sentences must have same probability score.

repository: ExplorerFreda/SyntaxEval

repo_name: ExplorerFreda/SyntaxEval


text:
# skyline-problem

Uses the solution from the Algorithms - Java project: [SkylineProblem](https://github.com/TheAlgorithms/Java/tree/master/SkylineProblem).

The problem is explained here: [Divide and Conquer | Set 7 (The Skyline Problem)](https://www.geeksforgeeks.org/divide-and-conquer-set-7-the-skyline-problem/). In fact, the demonstration data set comes from the article.

```json
{
  (1,11,5),
  (2,6,7),
  (3,13,9),
  (12,7,16),
  (14,3,25),
  (19,18,22),
  (23,13,29),
  (24,4,28)
}
```

The following illustration presents our visualization. On the left are each of the buildings; where visible and non visible portions are shown. On the right is the silhouette or skyline, where the solution is plotted as a set of points.

![Example](images/demo.png)

repository: lefilovi/skyline-problem

repo_name: lefilovi/skyline-problem


text:
# Hershel

Hershel is a CLI patcher for NDS ROMs. Written in Python, it aims to run on a
vast array of OSes, while using OpenPatch's human-readable patch format for the
purpose of clarity and ease of customization.

-----

## Requirements

To run Hershel, you'll need **Python 3.5** or greater.

To patch a ROM, you'll need its _original_ `.nds` file and an applicable patch.

-----

## Installation

No installation is needed: downloading this repository's `.zip` and unpacking
it to your preferred location will do.

-----

## Usage

Running:

    python hershel.py -h

Will provide a very brief usage summary:

    usage: hershel.py [-h] [-o OUTPUT | -i] [-c CRC32] input patch

    NDS ROM patcher which supports OpenPatch's patch format.

    positional arguments:
      input                 the ROM to patch
      patch                 the patch or database where the patch can be found

    optional arguments:
      -h, --help            show this help message and exit
      -o OUTPUT, --output OUTPUT
                            the path where to put the patched ROM
      -i, --in-place        apply the patch to the input file itself
      -c CRC32, --crc32 CRC32
                            force the patch for the ROM matching this CRC-32 to be
                            used
-----

## Command-line arguments

### Mandatory

`input`: this is the path to the `.nds` file you wish to patch;

`patch`: this is the path to the `.txt` file containing the patch you wish to
apply. The file can contain either a patch specific to the input ROM, or be a
database containing patches for different ROMs: in the latter case, Hershel
will automatically search the database, stopping at the first valid patch.

### Optional

Note: `-o/--output` and `-i/--in-place` are mutually exclusive.

`-o/--output`: this is the path and file name you wish the patched ROM to be
saved in. If not specified, it will default to `[input_name] (Patched).nds`;

`-i/--in-place`: tells Hershel to patch the input file itself, rather than a
copy of it. Saves time since it skips the copy operation. Disabled by default;

`-c/--crc32`: since a ROM's CRC-32 might differ from the one in the patch file,
Hershel could be unable to find an applicable patch. If you think your ROM to
be patchable, manually enter the CRC-32 found inside the patch to make Hershel
use said patch. _A valid CRC-32 is made of hex numbers and of length 8._

-----

## Sample runs

Three runs follow. The output has not been reported here.

### Minimal run

In this run, only the two mandatory arguments have been provided.

Starting files:
 - `rom.nds` (original ROM);
 - `patch.txt` (patch).

Command:

    python hershel.py rom.nds patch.txt

Resulting files:
 - `rom.nds` (original ROM);
 - `patch.txt` (patch);
 - `rom (Patched).nds` (patched ROM).

### Manually specifying the output path

In this run, we specify an output file name by hand with `-o`.

Starting files:
 - `rom.nds` (original ROM);
 - `patch.txt` (patch);

Command:

    python hershel.py rom.nds patch.txt -o patched-rom.nds

Resulting files:
 - `rom.nds` (original ROM);
 - `patch.txt` (patch);
 - `patched-rom.nds` (patched ROM).

### Overwriting the original ROM

Here we choose to modify the original ROM directly, skipping the creation of a
copy with `-i`. _Note that the original ROM will be lost._

Starting files:
 - `rom.nds` (original ROM);
 - `patch.txt` (patch);

Command:

    python hershel.py rom.nds patch.txt -i

Resulting files:
 - `rom.nds` (patched ROM);
 - `patch.txt` (patch).

-----

## Contributing

Before contributing, ensure that your code runs without errors and analyze it
with `pycodestyle`. If no errors or warnings are emitted, feel free to open a
pull request.

-----

## License

This project is licensed under the terms of the BSD 3-Clause license. See the
[LICENSE](LICENSE) file for details.

-----

## Acknowledgements

This project has been inspired by [nds-rom-patcher](https://github.com/al3xtjames/nds-rom-patcher) by [al3xtjames](https://github.com/al3xtjames).

repository: Nemris/Hershel

repo_name: Nemris/Hershel


text:
---
layout: post
title: "Comments on 'Band gap and band parameters of InN and GaN from quasiparticle energy calculations based on exact-exchange density-functional theory' Appl. Phys. Lett. 89, 161919 "
date: 2011-02-02 17:25:55
categories: arXiv_CV
tags: arXiv_CV GAN
author: D. Bagayoko, L. Franklin, G. L. Zhao
mathjax: true
---

* content
{:toc}

##### Abstract
An oversight of some previous density functional calculations of the band gaps of wurtzite and cubic InN and of wurtzite GaN by Rinke et al. [Appl. Phys. Lett. 89,161919, 2006] led to an inaccurate and misleading statement relative to limitations of density functional theory (DFT) for the description of electronic properties of these materials. These comments address this statement. In particular, they show that some local density approximation (LDA) calculations have correctly described or predicted electronic and related properties of these systems [Phys. Rev. B 60, 1563, 1999; J. Appl. Phys. 96, 4297, 2004, and 97, 123708, 2005]. These successful calculations solved self-consistently the system of equations defining LDA, i.e., the Kohn-Sham equation and the equation giving the ground state charge density in terms of the wave functions of the occupied states.

##### Abstract (translated by Google)

##### URL
[https://arxiv.org/abs/1102.0498](https://arxiv.org/abs/1102.0498)

##### PDF
[https://arxiv.org/pdf/1102.0498](https://arxiv.org/pdf/1102.0498)


text:
---
author: nhuhu
comments: false
date: 2015-02-10 08:49:46+00:00
layout: post
link: https://artificialcognition.wordpress.com/2015/02/10/creatures-part-1/
slug: creatures-part-1
title: 'Project: Autonomous Creatures Part 1'
wordpress_id: 119
---

So, I decided to try out that idea I had a few posts ago, combining both neural networks and genetic algorithms. This is gonna be pretty complicated, if it works, so I'm gonna break it down into smaller portions to do.

Today, I didn't do much. I basically set up everything, plopped a square thing in the centre as the creature, and thought about how it would move and scan the field for food/enemies.

Using a bit of maths, I think I can divide the playing field into 16 areas which would then be scanned and then the distance for each object could be calculated pretty easily. This info would then be fed into the neural net for it to do whatever it does.

Behold, my artistic masterpiece...

[![My artistic masterpiece... ](https://artificialcognition.files.wordpress.com/2015/02/grid.png?w=300)](https://artificialcognition.files.wordpress.com/2015/02/grid.png)

Anything further on, I still haven't decided on. But here's the code so far:

{% highlight python %}
import pygame, sys
from pygame.locals import *

pygame.init()

FPS = 100
fpsClock = pygame.time.Clock()

DISPLAYSURF = pygame.display.set_mode((600, 600))
pygame.display.set_caption('Ship')

WHITE = (255, 255, 255)

creature = Rect(0, 0, 20, 20)
critx = 300
crity = 300
creature.center = (critx, crity)

while True:
    DISPLAYSURF.fill(WHITE)
    pygame.draw.rect(DISPLAYSURF, (0,0,0), creature)

    for event in pygame.event.get():
        if event.type == QUIT:
            pygame.quit()
            sys.exit()

    pygame.display.update()
    fpsClock.tick(FPS)
{% endhighlight %}

And here's what it looks like right now, a lone square in the centre in the abyss:

[![And here's what it looks like right now, a lone square in the centre in the abyss.](https://artificialcognition.files.wordpress.com/2015/02/window-2015-02-10-at-21-49-07.png?w=291)](https://artificialcognition.files.wordpress.com/2015/02/window-2015-02-10-at-21-49-07.png)


text:
# nim-overpass

- [OpenStreetMap](https://openstreetmap.org) [Overpass](https://overpass-turbo.eu) API Lib,
[Async & Sync](https://github.com/juancarlospaco/nim-overpass/blob/master/src/overpass.nim#L74),
with & without SSL, [command line App (50Kb)](https://github.com/juancarlospaco/nim-overpass/releases).

![OpenStreetMap](https://raw.githubusercontent.com/juancarlospaco/nim-overpass/master/osm.jpg "OpenStreetMap")

# Install

- `nimble install overpass`

# Use

- `./overpass --color --lower --timeout=9 "node(1422314245)"`

- The output format is automatically set to JSON, `JsonNode` type.
- You must omit the `[out:json];` and `;out;` on the Query.

# Requisites

- None.

# API

`search*(this: Overpass | AsyncOverpass, query: string, api_url = api_main0)`

- `this` is `Overpass(timeout=int8)` for Synchronous code or `AsyncOverpass(timeout=int8)` for Asynchronous code.
- `query` is an overpass query, `string` type, required.
- `api_url` is an overpass HTTP API URL, `string` type, optional.

- The `timeout` argument is on Seconds.
- OpenStreetMap API limits the length of all key and value strings to a maximum of 255 characters.
- For Proxy support define a `Overpass.proxy` or `AsyncOverpass.proxy` of `Proxy` type.
- No OS-specific code, so it should work on Linux, Windows and Mac. Not JS.

# FAQ

- How to Edit the OpenStreetMap using this lib ?.

You can not, Overpass is a read-only OpenStreetMap API, but optimized for read speed.

- This works without SSL ?.

Yes.

- This works with SSL ?.

Yes.

- This works with Asynchronous code ?.

Yes.

- This works with Synchronous code ?.

Yes.

- This requires API Key or Login ?.

No.

- This requires Credit Card or Payments ?.

No.

- How do I build the Query string ?.

Use Nims [FMT strings module](https://nim-lang.org/docs/strformat.html).

repository: juancarlospaco/nim-overpass

gha_language: Nim

repo_name: juancarlospaco/nim-overpass


text:
[![Build Status](https://travis-ci.org/Inventory-Squad/inventory.svg?branch=master)](https://travis-ci.org/Inventory-Squad/inventory)
[![codecov](https://codecov.io/gh/Inventory-Squad/inventory/branch/master/graph/badge.svg)](https://codecov.io/gh/Inventory-Squad/inventory)
# Inventory
The inventory resource keeps track of how many of each product we have in our warehouse.

## Setting up your Development Environment
To get started, download and install VirtualBox and Vagrant.

### Install using Vagrant and VirtualBox
```bash
    git clone git@github.com:Inventory-Squad/inventory.git
    cd inventory
    vagrant up
    vagrant ssh
    cd /vagrant
```

## Manually running the Tests

### BDD
BDD integration tests are using Selenium to manipulate a web page on a running server.

Run the tests using `behave`
```shell
    $ honcho start &
    $ behave
```

Note that the `&` runs the server in the background. To stop the server, you must bring it to the foreground and then press `Ctrl+C`

Stop the server with
```shell
    $ fg
    $ <Ctrl+C>
```

Alternately you can run the server in another `shell` by opening another terminal window and using `vagrant ssh` to establish a second connection to the VM. You can also suppress all log output in the current shell with this command:

```bash
    honcho start 2>&1 > /dev/null &
```

or you can supress info logging with this command:

```bash
    gunicorn --bind <IP_ADDRESS> --log-level=error service:app &
```

This will suppress the normal `INFO` logging

### TDD
This repo also has unit tests that you can run `nose`

```bash
    $ nosetests
```

Nose is configured to automatically include the flags `--with-spec --spec-color` so that red-green-refactor is meaningful. If you are in a command shell that supports colors, passing tests will be green while failing tests will be red.

When you are done, you can exit and shut down the vm with:

```bash
    exit
    vagrant halt
```

If the VM is no longer needed you can remove it with:

```bash
    vagrant destroy
```

## Attributes

| Fields        | Type                                 |
| :------------ | :----------------------------------- |
| id  | String, read only                   |
| product_id    | Integer                              |
| quantity      | Integer                              |
| restock_level | Integer, when to order more          |
| condition     | String,  {'new', 'open_box', 'used'} |
| available     | Boolean                              |

## API Endpoint

An API to allow management of inventory for an e-commerce website. It will support create, read, update, delete, list, query, and an action(disable an entry).

##### Create a new inventory

- PATH: POST `/inventory`

##### Get an inventory by an inventory id

- PATH: GET `/inventory/{string:id} `

##### List all inventory

- PATH: GET `/inventory`

##### Query an inventory by a given attribute

- By product id:  GET `/inventory?product-id={int:pid}`
- By condition:  GET `/inventory?condition={string:condition} `
- By condition and product id: GET `/inventory?condition={string:condition}&product-id={int:pid} `
- By need restock or not: GET `/inventory?restock={bool:needRestock} `
- By restock level: GET `/inventory?restock-level={int:restock-level-value} `
- By availability: GET `/inventory?available={bool:isAvailable}`
- By availability and product id: GET /inventory?available={bool:isAvailable}&product-id={int:pid}

##### Delete an inventory

- PATH: DELETE `/inventory/{string:id} `

##### Disable an inventory

- PATH: PUT `/inventory/{int:product-id}/disable`

##### Update an inventory

- PATH: PUT `/inventory/{string:id}`

## View App with UI
https://nyu-inventory-service-f19.mybluemix.net/

## View Product with UI
https://nyu-inventory-service-f19-prod.mybluemix.net/

## Delivery Pipeline
https://cloud.ibm.com/devops/pipelines/5ef0d78c-44b1-4115-aa5d-8283a9ae61db?env_id=ibm:yp:us-south

## Swagger Documentation
https://nyu-inventory-service-f19-prod.mybluemix.net/apidocs/index.html

repository: Inventory-Squad/inventory

repo_name: Inventory-Squad/inventory


text:
---
layout: page
title: Fundamentals of Music
tagline: Teaching Details
---
{% include JB/setup %}

[Link to the current catalog description](http://catalog.scrippscollege.edu/preview_program.php?catoid=5&poid=902#)

Fundamentals of Music is an introductory music theory course taught at Scripps College.

## When Taught
<style>
th, td {
    padding:  0px 10px;
}
</style>

| Course | Sem | Year | Style | Website | Info | Final Exam or Project |
| ------ | --- | ---- | ----- | ------- | ---- | --------------------- |
| MUS3 | Fall | 1993 | Lecture, Lab, Practicum | N/A | N/A | N/A |


text:
phishing
========

Resources and a simple Python server demonstrating password phishing.

Concept
-------

Phishing is, in a modern sense, a social engineering attack using emails, instant messaging, and the like to try to get a victim to do something. In a traditional sense, this "something" is usually to divulge some information: most commonly a username and password combination. In a more modern sense, the user may also be tricked into doing something like running a malicious payload.

Spear phishing is the same attack but researched and delivered personally to a specific target. This kind of attack is very successful and accounts for the majority of successful attacks on corporate as of 2017.

Mitigation
----------

Similar to most, if not all, social engineering attacks, phishing exploits the user rather than the business and therefore mitigation may not be possible. In the case of stealing usernames and passwords, little can be done without affecting usability: forcing Two-Factor Authentication is a possible solution. A better idea is to ensure your customers know about about these kinds of attacks and how to prevent them, though obviously this will not be completely effective.

Most of the "effective" mitigation for phishing is actually a mitigation for when information is leaked. As with other social engineering attacks, a business should have structures and routines in place for the handling of sensitive information and should teach this well to all employees and users.

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

Included with this repository is a simple phishing page run on Flask. It is intended to demonstrate a phishing page during a MISC session.

You must have:

-	python >= 2.7, >= 3.5
-	Flask

After cloning the repository and `cd`ing into the legitbank.org directory, simply run:

```bash
$ sudo python run.py
```

Ensure you do not have anything else listening on port 80. Because this is such a simple app with a number of security flaws, I do not recommend hosting it using a web server such as nginx: just run it as a Python app and tear it down when you're done.

Security
--------

-	Rate limiting is not enabled.
-	Log rotation is not enabled.
	-	Coupled with a lack of rate limiting, if the server is left up for longer than required, the logs can take up a significant part of disk space very quickly.
-	Inputs are not checked or sanitised.
	-	Severity varies by Flask version.