text:
# Inventory-Management
A proof of concept store inventory interaction CLI using SQL

## Getting Started

Download the repository. Then, navigate to the folder and run install from your node package manager. If everything is installed, when you run `bew.js`, you should get a screen like this:

![Bob's Emporium of Wonders](readme/readme.gif "Bob's Emporium of Wonders")

Just follow the on screen instructions to explore the customer-side interface of my inventory management app.

![Employee Menu](readme/employee.png "Employee Menu")

If you pass `employee` as a command line argument, you'll be able to dive into the employee menus. Or, if you want to dive directly into a specific employee interface, you can use the `manager` or `supervisor` argument instead of employee.

![Manager Interface](readme/manager.gif "Manager Interface")

The manager interface allows you to see the current stock or just the products that are running low in inventory. You can also add more stock to an existing item or register a new item altogether.

![Supervisor](readme/supervisor.gif "Supervisor")

The supervisor interface tracks the total profit on purchases made with the customer interface. It also factors in overhead costs for each department as specified in the accompanying SQL table. Supervisors can also create new departments that will be reflected when they view the total profits afterwards.

### Prerequisites

You must have node installed in your terminal with support for the Node Package Manager. Also, you must have a local SQL server that you've initialised with the provided schema.

### Installing

[MySQL Website](https://www.mysql.com/)

Now we need to install MySQL. Navigate to the MySQL website and install the workbench and the local server.

![Install MySQL](readme/install-mysql.gif "Install MySQL")

Once you have them installed, start up your local database and use the provided `schema.sql` and `seeds.sql` files to initialize the database we're going to be using for this app. Make sure to execute `schema.sql` first! That has the blueprint for the database that we're going to seed with our initial dataset with `seeds.sql`.

[Node.js Website](https://nodejs.org/en/)

Navigate to the Node.js website and follow the instructions to install Node.  Just run
```
node bew.js
```

or

```
node bew.js employee
node bew.js manager
node bew.js supervisor
```

![Install](readme/install.gif "Install")

## Built With

* [Javascript](https://www.javascript.com/) - The scripting language used

* [SQL]() - Database management language

* [MySQL](https://www.mysql.com/) - Local Database hosting and management

* [Node.js](https://nodejs.org/en/) - JavaScript runtime

* [Node Package Manager](https://www.npmjs.com/) - Package manager for JavaScript and Node

* [Inquirer](https://www.npmjs.com/package/inquirer) - Command line user interface

* [mysql](https://www.npmjs.com/package/mysql) - Interface with SQL database

* [cli-table](https://www.npmjs.com/package/cli-table) - Display tables in the terminal

## Challenges

![SQL Join and Group](readme/sql-query.png "SQL Join and Group")

This project was my first time diving deep into SQL and its interactions with the backend. I had an interesting time figuring out how the different joins behave. This single SQL query best demonstrates combining several components together in a meaningful way.

![Display Table Callback](readme/callback.png "Display Table Callback")

I reused my function that displayed the items for sale in both the customer interface and the manager interface by passing in a callback function. I'm always on the lookout for ways to streamline my code.

![Text Align](readme/align-text.png "Text Align")

This is a series of functions I wrote to help with aligning text in the terminal. I use these to automatically center messages and create my own table-like display of the items for sale in the inquirer prompts. They're pretty simple, but I did feel pretty clever after I made them since they saved a lot of time.

## Authors

* **Robert Shaw** - *Initial work* - [robertshaw87](https://github.com/robertshaw87)


text:
### [CVE-2023-0001](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2023-0001)
![](https://img.shields.io/static/v1?label=Product&message=Cortex%20XDR%20agent&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=!%207.9%20All%20&color=brighgreen)
![](https://img.shields.io/static/v1?label=Vulnerability&message=CWE-319%20Cleartext%20Transmission%20of%20Sensitive%20Information&color=brighgreen)

### Description

An information exposure vulnerability in the Palo Alto Networks Cortex XDR agent on Windows devices allows a local system administrator to disclose the admin password for the agent in cleartext, which bad actors can then use to execute privileged cytool commands that disable or uninstall the agent.

### POC

#### Reference
No PoCs from references.

#### Github
- https://github.com/ARPSyndicate/cvemon
- https://github.com/Vinalti/cve-badge.li

license: MIT

repository: trickest/cve

branch_name: refs/heads/main

extension: md

gha_language: HTML

gha_license_id: MIT

license_type: permissive

repo_name: trickest/cve


text:
---
# Display name
name: Benjamin Avanzi

# Username (this should match the folder name)
authors:
- admin

# Is this the primary user of the site?
superuser: true

# Role/position
role: Professor of Actuarial Studies Non-Executive Director

# Organizations/Affiliations
organizations:
- name: The University of Melbourne
  url: "https://findanexpert.unimelb.edu.au/profile/795204-benjamin-avanzi"

# Short bio (displayed in user profile at end of posts)
bio: Benjamin Avanzi PhD Actuary SAA GAICD CERA is Professor of Actuarial Studies At the University of Melbourne. He worked as an actuarial consultant in Switzerland and Canada, was Executive Chairman of the Board of a Swiss pension fund from 2006 to 2008, and held full-time academic positions in Australia and Canada since 2008.

interests:
- Actuarial studies
- Risk management
- Insurance capital

education:
  courses:
  - course: Actuary SAA
    institution: Swiss Assocation of Actuaries
  - course: CERA
    institution: CERA Global Association
  - course: GAICD
    institution: Australian Institute of Company Directors (AICD)
  - course: PhD in Actuarial Science
    institution: University of Lausanne
    year: 2008
  - course: MSc in Economics, major in Actuarial Science
    institution: University of Lausanne
    year: 2005

# Social/Academic Networking
# For available icons, see: https://sourcethemes.com/academic/docs/page-builder/#icons
#   For an email link, use "fas" icon pack, "envelope" icon, and a link in the
#   form<EMAIL_ADDRESS>or "#contact" for contact widget.
social:
- icon: envelope
  icon_pack: fas
  link: '#contact'  # For a direct email link, use<EMAIL_ADDRESS>- icon: linkedin
  icon_pack: fab
  link: http://www.linkedin.com/in/benjaminavanzi
- icon: twitter
  icon_pack: fab
  link: https://twitter.com/ProfAvanzi
- icon: google-scholar
  icon_pack: ai
  link: https://scholar.google.ch/citations?user=X4Ur7VQAAAAJ
- icon: researchgate
  icon_pack: ai
  link: https://www.researchgate.net/profile/Benjamin_Avanzi
- icon: researchid
  icon_pack: ai
  link: https://publons.com/researcher/C-3888-2008/
- icon: orcid
  icon_pack: ai
  link: https://orcid.org/0000-0002-5424-4292
- icon: publons
  icon_pack: ai
  link: https://publons.com/researcher/1339617/benjamin-avanzi/
- icon: arxiv
  icon_pack: ai
  link: https://arxiv.org/a/avanzi_b_1.html
- icon: github
  icon_pack: fab
  link: https://github.com/agi-lab
- icon: youtube
  icon_pack: fab
  link: http://www.youtube.com/c/BenjaminAvanzi

# To enable, copy your resume/CV to `static/files/cv.pdf` and uncomment the lines below.
- icon: cv
  icon_pack: ai
  link: files/bavanziCV.pdf # Link to a PDF of your resume/CV from the About widget.

# Enter email to display Gravatar (if Gravatar enabled in Config)
email<EMAIL_ADDRESS>
# Organizational groups that you belong to (for People widget)
#   Set this to `[]` or comment out if you are not using People widget.
user_groups:
- Researchers
- Visitors
---

Benjamin Avanzi PhD Actuary SAA CERA GAICD is Professor of Actuarial Studies at the University of Melbourne.  He is also currently on the Management Board of the Theatre Royal (Hobart, Tasmania). He worked as an actuarial consultant in Switzerland and Canada, was Executive Chairman of the Board of a Swiss pension fund from 2006 to 2008, and held full-time academic positions in Australia and Canada since 2008.

Benjamin is an "Actuary SAA" with the Swiss Association of Actuaries (fully qualified actuary, equivalent to Fellow in Switzerland), an Affiliate member of the Australian Actuaries Institute, an Academic member of the Casualty Actuarial Society, as well as a member of the ASTIN section of the IAA. He is also a Chartered Enterprise Risk Actuary (CERA) and a Graduate member of the Australian Institute of Company Directors (GAICD).

Benjamin has published numerous papers in top actuarial and operations management journals. He was awarded (along with co-authors) the Hachemeister Prize twice by the Casualty Actuarial Society in 2017 and 2023, the Taylor Fry General Insurance Seminar Silver Prize in 2018, and a Highly Commended Paper Prize by the Institute and Faculty of Actuaries in 2022. He is an Editor of the ASTIN Bulletin, an Associate Editor of Insurance: Mathematics and Economics, as well as a member of the Editorial Board of the open access journal Risks.

repository: bavanzi/bavanzi-website

branch_name: refs/heads/master

repo_name: bavanzi/bavanzi-website


text:
# Take Hostage by Robbster

Instructions on how to use:
Type /takehostage, a valid weapon is needed(Add or remove weapons in cl_takehostage.lua)
Then press G to release the hostage or H to kill the hostage!

Feel free to make improvements with PRs


text:
---
layout: default
---

# 1994-03-30 - Crypto and new computing strategies

## Header Data

From<EMAIL_ADDRESS>(Eric Hughes)

To<EMAIL_ADDRESS>Message Hash: 419545cd0eaea3126215e5a0a3dfa1696b2531b1eca7c2a96cc6234773916107

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1994-03-30 20:23:42 UTC

Raw Date: Wed, 30 Mar 94 12:23:42 PST

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Eric Hughes)
Date: Wed, 30 Mar 94 12:23:42 PST
To<EMAIL_ADDRESS>Subject: Crypto and new computing strategies
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

>I am not shure that it has been demonstrated that a QM mechanis is necessarily
>solely of a Turing architecture.

The Bekenstein Bound gives limits both on the expected maximum number
of quantum states encodable in a given volume of space and on the
expected maximum number os transitions between these states.  If this
bound holds (and it certainly seems to hold for EM fields), then a
probabilistic Turing machine will be able to simulate it.

>Also there is the potential to use neural networks at these levels (which are
>not necessarily reducable to Turing models, the premise has never been proven)

If you have infinite precision, the statement is unproven.  If you
have finite precision, you get a Turing machine.  You never get
infinite precision in real life, even with quantum superposition.

Steve Smale did some work a few years ago where he made Turing-type
machines out of real numbers, i.e. infinite precision.  P=NP for this
model, and the proof is fairly easy.  From an information-theoretic
point of view, you can encode two real numbers inside of another one
and do computations in that encoded form, because a real number
encodes an infinite amount of information.

If it's finite, it's a Turing machine.  If it's expected finite, it's
a probabilistic Turing machine.  If it's infinite, it cannot be
implemented in hardware.

Eric

{% endraw %}
```

## Thread

+ Return to [March 1994](/archive/1994/03)

+ Return to "[Duncan Frissell <frissell@panix.com>](/authors/duncan_frissell_frissell_at_panix_com_)"
+ Return to<EMAIL_ADDRESS>(FutureNerd Steve Witham)](/authors/fnerd_at_smds_com_futurenerd_steve_witham_)"
+ Return to<EMAIL_ADDRESS>(Eric Hughes)](/authors/hughes_at_ah_com_eric_hughes_)"
+ Return to "[Jim choate <ravage@bga.com>](/authors/jim_choate_ravage_at_bga_com_)"
+ Return to<EMAIL_ADDRESS>(Mike McNally)](/authors/m5_at_vail_tivoli_com_mike_mcnally_)"
+ Return to<EMAIL_ADDRESS>(Robert M. Solovay)](/authors/solovay_at_math_berkeley_edu_robert_m_solovay_)"

+ 1994-03-30 (Tue, 29 Mar 94 16:29:26 PST) - [Re: Crypto and new computing strategies](/archive/1994/03/c892adcfebf9169dd14ed867186ada979572d4c44f2c5cdca346c0357148e7b4) -<EMAIL_ADDRESS>(FutureNerd Steve Witham)_
  + 1994-03-30 (Wed, 30 Mar 94 06:36:57 PST) - [Re: Crypto and new computing strategies](/archive/1994/03/be710732e104861809b29d2b7865adcbe8b1c654adb26bf50b165f691179aa3a) - _Jim choate<EMAIL_ADDRESS>    + 1994-03-30 (Wed, 30 Mar 94 07:00:29 PST) - [Re: Crypto and new computing strategies](/archive/1994/03/b0e3f833c4c3fb96011f985123672ca3a904a70e928dddb5c8ce803b8c6df133) -<EMAIL_ADDRESS>(Mike McNally)_
      + 1994-03-30 (Wed, 30 Mar 94 11:14:45 PST) - [Re: Crypto and new computing strategies](/archive/1994/03/ed04d89b4eb9530096ec5643f9b01fbfa8a2174e2a2b1a8bdc0b18ebbcf3e4a3) - _Jim choate<EMAIL_ADDRESS>        + 1994-03-30 (Wed, 30 Mar 94 11:12:31 PST) - [Re: Crypto and new computing strategies](/archive/1994/03/9877f444d02c45210450ddb62c9b39cfd9e61dc04a77b3fcfe47fe9cb836f7de) -<EMAIL_ADDRESS>(Mike McNally)_
          + 1994-03-30 (Wed, 30 Mar 94 12:39:29 PST) - [Re: Crypto and new computing strategies](/archive/1994/03/a18c82eb194ad3f8ed977b4f8e212e23b7eb9d86d113cd7cc28bf03a01eda004) - _Jim choate<EMAIL_ADDRESS>    + 1994-03-30 (Wed, 30 Mar 94 07:44:56 PST) - [Re: Crypto and new computing strategies](/archive/1994/03/68cfb54a67d958c36d33b650c9f1088cdd01d3f59055f3284357c4fbd5b46d62) - _Duncan Frissell<EMAIL_ADDRESS>      + 1994-03-30 (Wed, 30 Mar 94 11:38:31 PST) - [Re: Crypto and new computing strategies](/archive/1994/03/15a6b1252c061b29081c4eb91aa60adac199adc089fd09694a838f9a45a95fb9) - _Jim choate<EMAIL_ADDRESS>    + 1994-03-30 (Wed, 30 Mar 94 07:51:12 PST) - [Crypto and new computing strategies](/archive/1994/03/835b8285c3da41b36c5a590458631a2af8f48a9f91412feba22784ec76894b3c) -<EMAIL_ADDRESS>(Eric Hughes)_
      + 1994-03-30 (Wed, 30 Mar 94 11:10:56 PST) - [Re: Crypto and new computing strategies](/archive/1994/03/2418c9ce167f46ae941c1004a8c0b14b42d52426183ab4834e6f6400c5c1dfc0) - _Jim choate<EMAIL_ADDRESS>        + 1994-03-30 (Wed, 30 Mar 94 11:31:32 PST) - [Re: Crypto and new computing strategies](/archive/1994/03/6db1ef2429bc2c96da647de6caf1a7c35e39b5436cba4cec13908d7a5999b736) -<EMAIL_ADDRESS>(Mike McNally)_
          + 1994-03-30 (Wed, 30 Mar 94 12:36:20 PST) - [Re: Crypto and new computing strategies](/archive/1994/03/875288d3e0df02ad86d968bf30689048546a508d0a7dc26fd69ee2cbd0e01695) - _Jim choate<EMAIL_ADDRESS>            + 1994-03-30 (Wed, 30 Mar 94 12:46:38 PST) - [Re: Crypto and new computing strategies](/archive/1994/03/ad125184ad22e0673a91eccfa4a0308f30adba44decef9eeaa788a1a03d41b9c) -<EMAIL_ADDRESS>(Mike McNally)_
              + 1994-03-30 (Wed, 30 Mar 94 12:50:13 PST) - [Re: Crypto and new computing strategies](/archive/1994/03/a7308f36fa445e9bd8b9867dee1465c3547990a678fef92abea0de464ee80052) - _Jim choate<EMAIL_ADDRESS>        + 1994-03-30 (Wed, 30 Mar 94 12:23:42 PST) - Crypto and new computing strategies -<EMAIL_ADDRESS>(Eric Hughes)_
          + 1994-03-30 (Wed, 30 Mar 94 12:48:36 PST) - [Re: Crypto and new computing strategies](/archive/1994/03/7bc7aaa0ed2d8d3fae80065c93e65549ca810a93e176c66ccf514e49477e4659) - _Jim choate<EMAIL_ADDRESS>            + 1994-03-30 (Wed, 30 Mar 94 13:32:45 PST) - [Crypto and new computing strategies](/archive/1994/03/1ed652aa47d1aec60ef43234b3610c7f86166d168053fa15a128ccdb65037433) -<EMAIL_ADDRESS>(Eric Hughes)_
              + 1994-03-31 (Wed, 30 Mar 94 16:48:42 PST) - [Crypto and new computing strategies](/archive/1994/03/96112a1a3a8f0d4701a8b233ec630bd253fb78219fef62601dc0d9746018adbc) -<EMAIL_ADDRESS>(Robert M. Solovay)_
              + 1994-03-31 (Thu, 31 Mar 94 06:11:10 PST) - [Re: Crypto and new computing strategies](/archive/1994/03/eb07b4a7ca8d2b97bafa5ecd25814c33457175ce5f3d5ec40e7c676c4e9c1c28) - _Jim choate<EMAIL_ADDRESS>


text:
# Server Side Redux

## Concept

Run a Redux-like cycle on the server side to transform incoming events into database writes.

Basic ideas from [Turning The Database Inside Out](https://www.confluent.io/blog/turning-the-database-inside-out-with-apache-samza/) talk.

## Parts

- **Version**: All changes have a `version`, an arbitrary monotonously increasing sortable value.
- **Event**: An object with `version` (assigned by the queue), `type` and arbitrary `data` to describe a desired change to server state.
  - Examples: "this `user` logged in", "this `user` requested changing this `document`", "this `weatherData` arrived", …
- **Event queue**: A FIFO store, holding events until they are processed.
  - This should be a very reliable store.
  - When an `event` is put on the queue, it gets a unique incremented `version`.
- **State**: The state consists of sets of objects with at-least-per-set-unique-ids.
  - Database tables can store a row per set entry, so that's what we'll do. Each set is a table. We also store the current version in a separate one-row table (so that concurrent transactions conflict). The database is presumed to always be consistent (all tables and version in sync).
- **Middleware => Preprocessors**: Redux middleware is mostly implemented as preprocessor functions that run within the event handling transaction, and can alter the event based on data from all tables.
- **Reducers**: Reducers are pure functions that get current state and the event, and return a description of what should happen to the state to get to the next version.
  - Current state (the DB model) is accessed by calling (asynchronous) DB functions
  - Each reducer is responsible for a single set (table) and can't read other sets
  - Given the same state and event, the reducer always returns the same result
  - The result is an object `{error: {message: "..."}, set: [{id, ...}], rm: [id, ...], audit, ...}`
    - `error`: Present if the event can not be processed for some reason, contains information to debug the problem. This halts all event processing until the problem is fixed. To represent e.g. denial of requests, use a different key (ESModel uses `esFail`) and inspect the event result to see if it the request was granted.
    - Several keys are used by the JsonModel `applyEvent`:
      - `set`: objects to replace in the table
      - `ins`: objects to insert in the table (errors if exist)
      - `upd`: objects to shallow-update
      - `sav`: objects to shallow-update or insert if missing
      - `rm`: ids of objects to remove from the table
      - by subclassing, the behavior can be tweaked
    - any other keys: opaque data describing the change, can be informational or used by a custom `applyEvent`
  - **Derivers**: Functions that calculate "secondary state" from the changes. They can serve to make the event result smaller
- **History**: An ordered list of reduced events (so `{version, type, data, result}`). This is not required, and the event can be abridged. It could serve as an audit log. If all the original event data is retained, it can be used to reprocess the database from scratch.
- **Sub-events**: To make the event processing code simpler, ESDB allows dispatching further events from anywhere in the redux cycle. These events are processed depth-first. For example, a USER_LOGIN event can result in a USER_REGISTERED event if they logged in via OAuth for the first time.

## Flow

- Inbox cycle:

  - An event comes in. Think of events as newspaper headlines, they describe something that happened. They are not commands, they are facts and requests.
    - Any event that needs external information to process should be split up into multiple asynchronous events that have all the necessary data.
  - **Dispatch**: The event is stored on the queue and auto-assigned a version `v`

- Redux cycle:
  - **Wait for event**: get the v+1 event from the queue
  - **Preprocess**: `preprocess`ors can change the event object before it's passed to the reducers. They should return the new event object if they change it. Version cannot change, but e.g. id could be assigned.
  - **Reduce**:
    - The event is passed to all `reducer`s
    - Reducers produce a change description
    - Event object becomes history object with `result` attribute
  - **Apply**
    - Starts transaction
    - All results are written, including history object
    - The way they are written is arbitrary, implemented by an `applyEvent` method
  - **Derive**
    - `deriver`s are called with the history object
    - They change their models as they see fit
    - Failing derivers abort the transaction
    - Ends transaction. The DB is now at the event version.
- These steps run in a single transaction. If any step fails, the transaction is rolled back and retried later. All later events are held until the error is resolved, possibly through manual resolution. As such, avoid errors at all times. Events should be self-contained.

  - Listeners: They can get called with the history object after the Redux cycle completes

The Inbox flow can happen at any time; the Reduce/Write cycle happens sequentially.

If an incoming request is for some side-effect change, this should be stored as a sequence of events, recording the intent, the intermediate states and the end result. The database is then used by listeners to know the current state of side-effects.

## Advantages

All the advantages of Redux, but applied to the server:

- time travel (requires snapshots or reversible events (storing the full calculated change with the event))
- clean code, easy to unit test
- reprocessing: just start from 0
- reducers can run in parallel, interleaving I/O requests
- easy to generate audit log

## Limitations

### Risks

- Data loss can occur in all the normal ways, but the event log in essence duplicates the data
- The hard-line approach of failing events halting event processing can result in servers needing immediate care, but it is really the only sane way to handle data, and the event handling code should be robust

### Model

It is sometimes harder to model all changes as events, for example spawning side effects and keeping track of their state.

### Resource use

- Requires a data store with transactions, so that the new state and history is stored in one go.
- Not well suited for high-volume writes due to per-event "synchronous" updating. Caching can help. Reducers can run in parallel though.
- Not well suited for change sets exceeding available working memory. (e.g. delete all records). Those have to be special-cased within the `applyEvent` code.
- Not well suited for huge events (e.g. >2MB of data in the event). Move data out of the event into files etc.
- Single master for event queue. Sharding might help if that's a problem.

## Implementation

Up until v3 this was implemented by redux with changes for asynchronous behavior, but in v3 the concepts were implemented directly to allow for sub-events.

### GraphQL mutations

Mutations assume that they can return either with an Error or the result value of the mutation. This means keeping track of the event execution as it passes through all the layers. To that end, `dispatch` tracks event completion even if it happened in another process.

## DevOps Scenarios

### Start from existing database

- Add history and version table, mark all tables as a first version
- Add new reducers, see below

### Add new table/reducer

- Add reducer to reducers
- Either:
  - Calculate/provide table at current db version in a migration
  - Start empty, run all stored events

### Change reducer

- Change reducer in reducers
- Either:
  - Convert table in a migration
  - Start empty, run all stored events

### Running out of disk

- Prune history
  - Remove old entries, perhaps keeping the last X, as well as important ones
  - Remove metadata of old entries, perhaps only keeping the audit information
- Upgrade the server

### Running out of CPU

- Shard DB: create more writers
  - Copy the DB to multiple masters
  - Replace the reducers with sharding versions
  - Update tables in a migration, pruning data not belonging to the shard
- Duplicate servers: create more readers
  - Copy the DB etc to multiple readers
  - Synchronize events so there is absolute ordering and no previous version insertions after a version was stored in the DB
- Upgrade the server

repository: Dzieni/strato-db

path: /Server Side Redux.md

filename: Server Side Redux.md

repo_name: Dzieni/strato-db


text:
# Machine Setup

In this part of the tutorial, you will install the necessary dependencies to run Java and connect to Azure SQL.

## Install Java

If you already have Java installed on your machine, skip the next two steps. Install the Java Runtime Environment (JRE) using the following command.

```terminal
  sudo apt-get install default-jre
```

## Install the Java Development Kit (JDK)

```terminal
sudo apt-get install default-jdk
```
## Install Maven

[Maven](https://maven.apache.org/) can be used to help manage dependencies, build, test and run your Java project.

```terminal
  sudo apt-get install maven
```
Check that you have Maven properly installed by running the following command.

```terminal
mvn -v
```

# Return to the [**main page**](https://github.com/Azure-Samples/AzureSqlGettingStartedSamples/tree/master/java/Unix-based#start-writing-apps-with-java-and-azure-sql) to complete the tutorial.


text:
# wolf, wild dogs

## Definition:

A wolf is a fierce, meat-eating animal that is similar to a wild dog.

* Wolves usually hunt in groups and stalk their prey in a clever and stealthy manner.
* In the Bible, the term “wolves” is used figuratively to refer to false teachers or false prophets who destroy believers, who are compared to sheep. False teaching causes people to believe wrong things that bring harm to them.
* This comparison is based on the fact that sheep are especially vulnerable to being attacked and eaten by wolves, because they are weak and cannot defend themselves.

## Translation Suggestion

* This term could be translated as “wild dog” or “wild animal.”
* Other names for wild dogs could be “jackal” or “coyote.”
* When used figuratively to refer to people, this could be translated as “evil people who harm people like animals that attack sheep.”

(See also: [evil](../kt/evil.md), [false prophet](../other/falseprophet.md), [sheep](../other/sheep.md), [teach](../other/teach.md))

## Bible References:

* [Acts 20:29](rc://en/tn/help/act/20/29)
* [Isaiah 11:7](rc://en/tn/help/isa/11/07)
* [John 10:11-13](rc://en/tn/help/jhn/10/11)
* [Luke 10:3](rc://en/tn/help/luk/10/03)
* [Matthew 7:15](rc://en/tn/help/mat/07/15)
* [Zephaniah 3:3](rc://en/tn/help/zep/03/03)

## Word Data:

* Strong’s: [[H2061]], [[H3611]], [[G03074]]

repository: mandolyte/uw-obsidian

repo_name: mandolyte/uw-obsidian


text:
# Virtual Environments Exercise 1

1. Make a mock project directory "myproject" in your home directory:

   `cd ~ && mkdir myproject`

2. cd into this myproject directory

    `cd myproject`

3. Exit your current virtualenv using the "deactivate" command.
  - *Note*: Upon login to the lab host a virtual environment for your user is automatically activated, so we need to "deactivate" to get "out" of this virtual environment.

4. Create a new virtual environment named 'venv'

    `python -m venv`

5. Activate that virtual environment using:

    `source venv/bin/activate`

6. Execute the `pip list` command to make sure you have a blank virtual environment.

7. Use `pip install netmiko` to reinstall the netmiko library.

8. View `pip list` again to see what is now installed.

9. Optionally export the packages installed in your virtual environment to a `requirements.txt` file. This file could be shared with others so that they are able to reproduce your virtual environment.

    `pip list > requirements.txt`

repository: twin-bridges/ansible-ons

repo_name: twin-bridges/ansible-ons


text:
# Project6-air-quality-prediction

#This is a data science project using python with the main objective to use machine learning to predict air quality in a Italy city

#there is one dataset in this project:

#AirQualityUCI with 9358 instances and 15 variables

# Variables:

#Date

#Time

#CO(GT)

#PT08.S1(CO)

#NHMC(GT)

#C6H6(GT)

#PT08.S2(NHMC)

#NOx(GT)

#PT08.S3(NOx)

#NO2(GT)

#PT08.S4(NO2)

#PT08.S5(O3)

#T

#RH

#AH

# Data Source:
https://archive.ics.uci.edu/ml/datasets/Air+Quality#

# Citations
#S. De Vito, E. Massera, M. Piga, L. Martinotto, G. Di Francia, On field calibration of an electronic nose for benzene estimation in an urban pollution monitoring scenario, Sensors and Actuators B: Chemical, Volume 129, Issue 2, 22 February 2008, Pages 750-757, ISSN 0925-4005, [Web Link].
([Web Link])


text:
# Hemimycena praedecurrens (Murrill) Singer SPECIES

#### Status
ACCEPTED

#### According to
Index Fungorum

#### Published in
Nova Hedwigia 29(1-2): 26 (1977)

#### Original name
Marasmius praedecurrens Murrill

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
# !! THIS REPO IS NOT IN USE ANY MORE AND HAS SECURITY VULNERABILITIES !!

# SD Discord Bot
This bot is a modified version of [Owen Conti's](https://github.com/owenconti/) LiveCoding.tv chatbot.
The structure is the same as his bot, but some core files has been changed to fit [discord.io](https://github.com/izy521/discord.io)

## Create a plugin for the bot

```javascript
'use strict'

const runtime = require('../utils/Runtime');
const regex = new RegExp( "^("Your prefix here")ping$" );

module.exports = [{
    name: 'ping',
    types: ['message'],
    regex: regex,
    action: function( chat, stanza ) {
        chat.sendMessage('pong', stanza);
    }
}];
```
*More readme comming later*

# License
The MIT License (MIT)

Copyright (c) 2016 RavingAPD

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

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

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


text:
# @readme/variable

React component for Variables

[![Build](https://github.com/readmeio/api-explorer/workflows/CI/badge.svg)](https://github.com/readmeio/api-explorer/tree/master/packages/variable)

[![](https://d3vv6lp55qjaqc.cloudfront.net/items/1M3C3j0I0s0j3T362344/Untitled-2.png)](https://readme.io)

## Installation

```
npm install --save @readme/variable
```

## Usage

## Credits
[Dom Harrington](https://github.com/domharrington/)

## License

ISC

license: MIT,ISC

detected_licenses: MIT ISC


text:
## gitfs

_Better repository management for the everyday developer._

When starting a job at any company, you often spend a fair amount setting up your development environment.
This involves installing dependent tooling, cloning repositories, amongst many other things.
`gitfs` was developed to ease some of that process by removing the need to manually clone down every repository.
Instead, it creates a virtual directory structure around git urls, making it easy to navigate sources for projects.

## Support

Support on this library is limited right now, but open to and under active development.
Below, you will find some of the current limitations / capabilities for the project.

![GitHub](https://img.shields.io/github/license/deps-cloud/gitfs.svg)
[![Build Status](https://travis-ci.com/deps-cloud/gitfs.svg?branch=master)](https://travis-ci.com/deps-cloud/gitfs)
[![Go Report Card](https://goreportcard.com/badge/github.com/deps-cloud/gitfs)](https://goreportcard.com/report/github.com/deps-cloud/gitfs)

### Limited Remote Implementations

Currently, gitfs supports a generic endpoint, but are open to supporting new remotes for various integrations.
We are planning to support Github, Gitlab, and Bitbucket in the short term.
PR's for each of these remotes based on their [config](pkg/config/config.proto) definitions are welcome.

- [x] [gh-3: Add remote implementation for gitlab](https://github.com/deps-cloud/gitfs/issues/3)
- [ ] [gh-2: Add remote implementation for bitbucket](https://github.com/deps-cloud/gitfs/issues/2)
- [x] [gh-1: Add remote implementation for github](https://github.com/deps-cloud/gitfs/issues/1)

## Getting Started

Getting started with this tool can be a little bit of a hassle for now.
It will get better over time as development continues on the project.

### Prerequisites

**libfuse**

You'll need to install FUSE on your system in order to use this project.
For directions on how to install, see the [libfuse](https://github.com/libfuse/libfuse) github page.

```
sudo apt-get install libfuse-dev   # Ubuntu/Debian
sudo pacman -S fuse                # Manjaro/Arch

brew cask install osxfuse          # OSX
```

### Releases

Releases for this project can be found here under github's releases integration.

https://github.com/deps-cloud/gitfs/releases

### Configuring gitfs

Once the binary has been installed, you will need to configure `gitfs`.
By default, `gitfs` looks for a configuration file at `${HOME}/.gitfs/config.yml`.
The location of the config file can be changed using the `-config` parameter.
Below, I have provided a snippet on the configuration required for using github as a remote.

```yaml
# cat ${HOME}/.gitfs/config.yml
mount: "${HOME}/Development/code"
accounts:
  - github:
      oauth2:
        token: <oauth_token>
      users:
      - <username>
clone:
  repositoryRoot: "${HOME}/.gitfs/cache" # this is where your repos will be cloned
  depth: 0 # depth 0 means full clone
```

### Running gitfs

Once your configuration has been created and values have been replaced, you can run `gitfs start`.
Note that running `gitfs` will spawn the filesystem service as a blocking process in your active terminal window.
You can run this as a systemctl daemon, but I find having access to the logs more readily at this time is a bit nicer.

To run, simply execute `gitfs start`.
When run successfully, you should see an output message similar to the one below.

```
$ gitfs start
INFO[0000] [main] configured mount point: /Users/deps-cloud/Development/code
INFO[0000] [main] fetching repositories
INFO[0000] [remotes.github] processing organizations for user: deps-cloud
INFO[0000] [remotes.github] processing repositories for user: deps-cloud
INFO[0001] [main] parsing repositories into a directory structure
INFO[0001] [main] attempting to mount /Users/deps-cloud/Development/code
INFO[0001] [main] now serving file system
```

In a separate window, navigate to your configured `mount` point.
For me, I have this set `${HOME}/Development/code`.
From this directory, you should be able to navigate your projects on Github.

```
[deps-cloud@deps-cloud ~/Development/code]
$ ls
github.com

[deps-cloud@deps-cloud ~/Development/code]
$ cd github.com/

[deps-cloud@deps-cloud ~/Development/code/github.com]
$ ls
deps-cloud

[deps-cloud@deps-cloud ~/Development/code/github.com]
$ cd deps-cloud/

[deps-cloud@deps-cloud ~/Development/code/github.com/deps-cloud]
$ ls
OpenGrok	   grpc-java	    laas	rpi
consul-api	   grpc.github.io   deps-cloud.com	seo-portal
docker-clickhouse  grpcsh	    mp		serverless-plugin-simulate
docker-utils	   hbase-docker     okhttp	simple-daemon-node
dotfiles	   idea-framework   proctor	spring-config-repo
generator-idea	   java-gitlab-api  proctorjs
gitfs		   jgrapht	    proto2-3

[deps-cloud@deps-cloud ~/Development/code/github.com/deps-cloud]
$ cd grpcsh

[deps-cloud@deps-cloud ~/Development/code/github.com/deps-cloud/grpcsh master]
$ ls
README.md  bin	package-lock.json  package.json  yarn.lock
```

### Stopping gitfs

In order to stop the gitfs server, you will need to run the `stop` command.
This forces the FUSE volume to be unmounted.

```bash
$ gitfs stop
INFO[0000] Unmounting /Users/deps-cloud/Development/code
INFO[0000] Successfully unmounted /Users/deps-cloud/Development/code
```

Should you run this command and find that the file system did not unmount, you can try using `umount`.

```bash
# replace with your mount point
$ sudo umount -f <your_mount_point>
```

repository: depscloud/gitfs

repo_name: depscloud/gitfs


text:
---
title: "The Very Large LED Array"
cover: "./images/looking-smug.jpg"
description: "A 64x32 LED display with a livecoding interface"
date: "2014-12-10"
---
![](images/looking-smug.jpg)

squarepusher from Owen Trueblood on Vimeo.

## Driving an LED Array from Shaders Running on a Raspberry Pi

The Very Large LED Array, or VLLA for short, is a bunch of LEDs mounted on a 4x8'
sheet of plywood driven by two Teensy microcontrollers and a Raspberry Pi. The
hardware was designed and [constructed by friends of mine](https://e2e.ti.com/group/universityprogram/students/m/students_repository/664650)
for our hall in our dorm at MIT with funding from Texas Instruments. The goal was
to create an impressive light show for parties.

I was interested in the software driving the display and had a desperate need to
obsess over something not school related at the end of my 2nd semester in my
junior year, so I developed a series of tools for creating effects for the display.
In its final form the system could run effects written in JavaScript or Lua, piped
frame-by-frame over UDP, read from GIFs, or streamed from pixels on a Linux desktop.

doctor from Owen Trueblood on Vimeo.

madeon from Owen Trueblood on Vimeo.

flutebox from Owen Trueblood on Vimeo.

roland from Owen Trueblood on Vimeo.

cats-on-mars from Owen Trueblood on Vimeo.

beats-around-madison from Owen Trueblood on Vimeo.

## Rotating a Panda

Panda LED Effect Demo from Owen Trueblood on Vimeo.

One of the first effects I developed for the VLLA was directly inspired by a
loading screen in a demo by Fairlight called We Are New. In the demo a
pistol-wielding panda rendered in chunky volumetric form rotated in 3D space.

You can find my code to recreate the effect below:


text:
![ScrollController](assets/cover.png)
# ScrollController

ScrollController is a Framer module that helps you to animate, pin and trigger events based on scroll position. It's the module you need, if you want to:

- animate based on scroll position
- start an animation at a specific scroll position
- synchronise an animation to the scroll movement
- pin a layer indefinitely at a specific scroll position
- pin a layer for a limited amount of scroll progress
- add callbacks at specific scroll positions passing a progress parameter
- easily create parallax effect
- create infinite scrolling
- create sticky headers

_Works with [Framer](https://framer.com) v120 or later_

#### Table of contents
[Installation](#installation)
[Demo](#demo)
[Quick start](#quick-start)
[Documentation](#documentation)
[Known limitations](#known-limitations)
[Releases](#releases)
[License](#license)
[Author](#author)
[Acknowledgement](#acknowledgement)

## Installation

#### Install with Framer Modules

1. Open your project in Framer.
2. Start Framer Modules and select `ADD MODULE`.
3. Search for `ScrollController`, once found hit enter to install into your prototype.

    <img alt='Install with Framer Modules'
<EMAIL_ADDRESS>width='160' height='40' />

#### Install manually

1. Open your project in Framer.
2. Download and unzip the module.
3. Drag the file `ScrollController.coffee` into the code editor.
4. Change `ScrollController` to `{ScrollController}` in the require command

## Demo

![ScrollController Example](assets/scrollcontroller_example.gif)

## Quick start
To get started using the `ScrollController` you must start by creating a `Controller` to make the required connection to the `ScrollComponent`. Secondly you must add at least one `Scene` which defines in what part of the page/view something should happen. Finally you may add at least one `Tween` or `Pin` to define what needs to happen. Alternatively you may listen for events with callbacks to trigger your prototype.

##### Step 1: Import module
```coffee
# Import module
{ScrollController} = require 'ScrollController'
```

##### Step 2: Create setting (with built-in components)
```coffee
# Create ScrollComponent
myScrollComponent = new ScrollComponent
	frame: Screen.frame
	scrollHorizontal: false

# Create container
myContainer = new Layer
	parent: myScrollComponent.content
	width: Screen.width
	height: Screen.height*2
	backgroundColor: null

# Create layer
myLayer = new Layer
	parent: myContainer
	point: Align.center
```

##### Step 3: Create controller and add scene, tween and pin
```coffee
# Create controller
myController = new ScrollController
	source: myScrollComponent

# Add scene
myScene = myController.addScene
	triggerLayer: myLayer
	duration: 200
	guide: true

# Add tweeen
myTween = myScene.addTween
	to: {rotation: -90, scale: 0.2, backgroundColor: "#00AAFF"}
	options: {time: 0.25, curve: "Spring"}

# Add pin
myPin = myScene.addPin()
```

##### Step 4: Listen for events with callback
```coffee
# Listen for event with callback
myScene.onProgress (event, instance) ->
  myTextLayer.text = "#{event.progress}"
```

## Documentation
ScrollController consists of 4 components: `Controller`, `Scene`, `Tween` and `Pin`. Learn about each components and its properties in the documentation:

#### Components
[Controller](#controller)
[Scene](#scene)
[Tween](#tween)
[Pin](#pin)

### Controller
The controller establishes the required connection to the ScrollComponent and manages attached scenes by either updating or refreshing them whenever the ScrollComponent changes its size or when its scroll position changes. The controller manages one direction - create two controllers if you need to manage both horizontal and vertical movement at the same time.

| Property | Type | Default | Description |
| :--- | :--- | :--- | :--- |
| [`new ScrollController`](#new-scrollcontroller) | Class | - | Create controller |
| `Controller.source` | Object | - | Get controller source |
| `Controller.name` | String | `"."` | Get/Set controller name |
| `Controller.direction` | String | `"vertical"` | Get controller scroll direction |
| `Controller.throttle` | Number | `0` | Get/Set controller throttling |
| `Controller.enabled` | Boolean | `true` | Get/Set controller enabled state |
| [`Controller.addScene`](#controlleraddscene) | Method | - | Add scene to controller |
| [`Controller.removeScene`](#controllerremovescene) | Method | - | Remove scene from controller |
| [`Controller.scrollTo`](#controllerscrollto) | Method | - | Scroll to scene, progress, layer or offset |
| [`Controller.update`](#controllerupdate) | Method | - | Force controller update |
| [`Controller.refresh`](#controllerrefresh) | Method | - | Force controller refresh |
| [`Controller.remove`](#controllerremove) | Method | - | Remove controller |

#### new ScrollController
Create controller.

##### Parameters:
- `source` – ScrollComponent instance – _required_
- `name` – controller name
- `direction` – controller scroll direction
- `throttle` – controller throttling
- `enabled` – controller enabled state

```coffee
# Create controller with default properties
myController = new ScrollController
  source: myScrollComponent

# Create controller with custom properties
myController = new ScrollController
  source: myScrollComponent
  name: "myControllerName"
  direction: "horizontal"
  throttle: 0.01
  enabled: false
```

#### Controller.addScene
Add scene to controller.

##### Parameters:
- `name` – scene name
- `triggerLayer` – scene triggerLayer to define the start of the scene
- `offset` – scene offset, from top/left of screen or from triggerLayer
- `duration` – scene duration
- `needle` – scene needle position, from begining to end of screen (0 to 1)
- `reverse` – scene reversable state
- `enabled` – scene enabled state
- `guide` – scene guide markers
- `guideNeedleColor` – scene guide needle color
- `guideStartColor` – scene guide start color
- `guideEndColor` – scene guide end color
- `guideIndent` – scene guide indent

```coffee
# Add scene to controller with default properties
myScene = myController.addScene()

# Add scene to controller with custom properties
myScene = myController.addScene
  name: "mySceneName"
  triggerLayer: myLayer
  offset: -100
  duration: 200
  needle: 0.65
  reverse: false
  enabled: false
  guide: true
  guideNeedleColor: "blue"
  guideStartColor: "green"
  guideEndColor: "red"
  guideIndent: 40
```

#### Controller.removeScene
Remove scene from controller.

##### Parameters:
- `reset` – reset scene and all connected tweens and pins

```coffee
# Remove scenes and all connected tweens and pins
myController.removeScene myScene

# Remove and reset scene and all connected tweens and pins
myController.removeScene myScene, true
```

#### Controller.scrollTo
Scroll to scene, scene progress, layer and offset

##### Parameters:
- `element` – scene or layer
- `progress` – scene progress (0 to 1)
- `offset` – offset

```coffee
# Scroll to scene
myController.scrollTo
  element: myScene

# Scroll to scene progress
myController.scrollTo
  element: myScene
  progress: 0.25

# Scroll to layer
myController.scrollTo
  element: myLayer

# Scroll to offset
myController.scrollTo
  offset: 100

# Scroll to scene progress with offset
myController.scrollTo
  element: myScene
  progress: 0.25
  offset: 100
```

#### Controller.update
Update controller by recalculating scene, tween and pin properties then automatically refreshing the controller. This happens automatically and should only be used when required.

```coffee
# Update controller
myController.update()
```

#### Controller.refresh
Refresh controller by redrawing scenes, tweens and pins. This happens automatically and should only be used when required.

```coffee
# Refresh controller
myController.refresh()
```

#### Controller.remove
Remove controller.

##### Parameters:
- `reset` – reset controller and all connected scenes, tweens and pins

```coffee
# Remove controller and all connected scenes, tweens and pins
myController.remove()

# Remove and reset controller and all connected scenes, tweens and pins
myController.remove true
```

### Scene
The scene defines in what part of the page/view something should happen and manages all attached tweens and pins. The scene has a start position defined by either a layer (triggerLayer) and/or an offset (from the triggerLayer or from top/left of screen if no triggerLayer is defined). The scene can also have an end if a duration is defined. Every scene has a needle (defined by a number between 0 and 1, start of screen is 0, end of screen is 1). The needle triggers events once it reaches the start, the end and whenever it enters, progresses and leaves the scene. A scene can be setup easily and precisely by enabling the guide.

| Property | Type | Default | Description |
| :--- | :--- | :--- | :--- |
| `Scene.source` | Object | `ScrollComponent` | Get scene ScrollComponent |
| `Scene.controller` | Object | `Controller` | Get scene controller |
| `Scene.name` | String | `"."` | Get/Set scene name |
| `Scene.triggerLayer` | Layer | `Undefined` | Get/Set triggerLayer |
| `Scene.needle` | Number | `0.5` | Get/Set scene needle (0 to 1) |
| `Scene.offset` | Number | `0` | Get/Set scene offset |
| `Scene.duration` | Number | `0` | Get/Set scene duration |
| `Scene.reverse` | Boolean | `true` | Get/Set scene reversable state |
| `Scene.enabled` | Boolean | `true` | Get/Set scene enabled state |
| `Scene.guide` | Boolean | `false` | Get scene guide |
| `Scene.guideNeedleColor` | Color | `"#0066FF"` | Get scene guide needle guide |
| `Scene.guideStartColor` | Color | `"#009933"` | Get scene guide start color |
| `Scene.guideEndColor` | Color | `"#FF3333"` | Get scene guide end color |
| `Scene.state` | String | `"before"`, `"during"` or `"after"` | Get scene state |
| `Scene.progress` | Number | - | Get scene progress (0 to 1) |
| `Scene.start` | Number | - | Get scene start |
| `Scene.end` | Number | - | Get scene end |
| `Scene.needlePos`| Number | - | Get scene needle position |
| `Scene.scrollOffset` | Number | - | Get scene scroll offset |
| `Scene.offsetStart` | Number | - | Get scene offset start |
| `Scene.offsetEnd`| Number | - | Get scene offset end |
| `Scene.tweens` | Array | - | Get scene tweens |
| `Scene.pins` | Array | - | Get scene pins |
| [`Scene.addTween`](#sceneaddtween) | Method | - | Add scene tween |
| [`Scene.removeTween`](#sceneremovetween) | Method | - | Remove scene tween |
| [`Scene.addPin`](#sceneaddpin) | Method | - | Add scene pin |
| [`Scene.removePin`](#sceneremovepin) | Method | - | Remove scene pin |
| [`Scene.trigger`](#scenetrigger) | Method | - | Trigger scene event |
| [`Scene.update`](#sceneupdate) | Method | - | Force scene update |
| [`Scene.refresh`](#scenerefresh) | Method | - | Force scene refresh |
| [`Scene.remove`](#sceneremove) | Method | - | Remove scene |
| [`Scene.onChangeValue`](#sceneonevent) | Event | - | On change value |
| [`Scene.onShift`](#sceneonevent) | Event | - | On shift |
| [`Scene.onUpdate`](#sceneonevent) | Event | - | On update |
| [`Scene.onEnter`](#sceneonevent) | Event | - | On enter |
| [`Scene.onStart`](#sceneonevent) | Event | - | On start |
| [`Scene.onProgress`](#sceneonevent) | Event | - | On progress |
| [`Scene.onEnd`](#sceneonevent) | Event | - | On end |
| [`Scene.onLeave`](#sceneonevent) | Event | - | On leave |

#### Scene.addTween
Add tween to scene.

##### Parameters:
- `name` – tween name
- `layer` – tween layer
- `from` – tween from properties object - _required if no to properties_
- `to` – tween to properties object - _required if no from properties_
- `options` – tween animation object
- `init` – tween initialisation state
- `enabled` – tween enabled state

```coffee
# Add tween to scene with default properties
myTween = myScene.addTween
  from: {opacity: 0}

# Add tween to scene with custom properties
myTween = myScene.addTween
  name: "myTween"
  layer: myOtherLayer
  from: {rotation: 0, scale: 2, backgroundColor: "white"}
  to: {rotation: -90, scale: 0.2, backgroundColor: "#00AAFF"}
  options: {time: 0.25, curve: "Spring", colorModel: "rgb"}
  init: true
  enabled: false
```

#### Scene.removeTween
Remove tween from scene.

##### Parameters:
- `reset` – reset tween

```coffee
# Remove tween
myScene.removeTween myTween

# Remove and reset tween
myScene.removeTween myTween, true
```

#### Scene.addPin
Add pin to scene.

##### Parameters:
- `name` – pin name
- `layer` – pin layer
- `enabled` – pin enabled state

```coffee
# Add pin to scene with default properties
myPin = myScene.addPin()

# Add pin to scene with custom properties
myPin = myScene.addPin
  name: "myPinName"
  layer: myOtherLayer
  enabled: false
```

#### Scene.removePin
Remove pin from scene.

##### Parameters:
- `reset` – reset pin

```coffee
# Remove pin
myScene.removePin myPin

# Remove and reset pin
myScene.removePin myPin, true
```

#### Scene.trigger
Trigger scene event.

##### Parameters:
- `name` – event name to trigger – _required_
- `event` – event object for callback

```coffee
# Trigger scene event
myScene.trigger
  name: "enter"
  event: {myVar}
```

#### Scene.update
Update by recalculating scene, tween and pin properties then automatically refreshing the scene. This happens automatically and should only be used when required.

```coffee
# Update scene
myScene.update()
```

#### Scene.refresh
Refresh scene by redrawing tweens and pins. This happens automatically and should only be used when required.

```coffee
# Refresh scene
myScene.refresh()
```

#### Scene.remove
Remove scene from controller.

##### Parameters:
- `reset` – reset scene and all connected tweens and pins

```coffee
# Remove scene and all connected tweens and pins
myScene.remove()

# Remove and reset scene and all connected tweens and pins
myScene.remove true
```

#### Scene.onEvent
Listen for scene events.

##### Event listeners
```coffee
# Listen for scene change
myScene.onChangeValue ->
  print "Scene changed"

# Listen for scene shift
myScene.onShift ->
  print "Scene shifted"

# Listen for scene update
myScene.onUpdate ->
  print "Scene updated"

# Listen for scene enter
myScene.onEnter ->
  print "Scene entered"

# Listen for scene start
myScene.onStart ->
  print "Scene started"

# Listen for scene progress
myScene.onProgress ->
  print "Scene progressed"

# Listen for scene end
myScene.onEnd ->
  print "Scene ended"

# Listen for scene leave
myScene.onLeave ->
  print "Scene left"
```

##### Event listeners with callbacks
```coffee
# Listen for scene change with callback
myScene.onChangeValue (event, instance) ->
  print "Scene changed"
  print "Event: #{event.property}, #{event.value}"

# Listen for scene shift with callback
myScene.onShift (event, instance) ->
  print "Scene shifted"
  print "Event: #{event.reason}"

# Listen for scene update with callback
myScene.onUpdate (event, instance) ->
  print "Scene updated"
  print "Event: #{event.start}, #{event.end}, #{event.scrollPos}"

# Listen for scene enter with callback
myScene.onEnter (event, instance) ->
  print "Scene entered"
  print "Event: #{event.progress}, #{event.state}, #{event.scrollDir}"

# Listen for scene start with callback
myScene.onStart (event, instance) ->
  print "Scene started"
  print "Event: #{event.progress}, #{event.state}, #{event.scrollDir}"

# Listen for scene progress with callback
myScene.onProgress (event, instance) ->
  print "Scene progressed"
  print "Event: #{event.progress}, #{event.state}, #{event.scrollDir}"

# Listen for scene end with callback
myScene.onEnd (event, instance) ->
  print "Scene ended"
  print "Event: #{event.progress}, #{event.state}, #{event.scrollDir}"

# Listen for scene leave with callback
myScene.onLeave (event, instance) ->
  print "Scene left"
  print "Event: #{event.progress}, #{event.state}, #{event.scrollDir}"
```

### Tween
The tween defines what happens in a scene by animating a defined layer (triggerLayer by default) between states defined by from and/or to properties. The tween will start its animation (with its defined animation options) when its scene starts or it will modulate based on scroll progress between from and to when its scene starts until it ends if the scene has a duration. Multiple tweens can be added on the same layer with the same properties if their scenes are defined in succession and the tweens define both from and to properties and disable their initialisation.

| Property | Type | Default | Description |
| :--- | :--- | :--- |  :--- |
| `Tween.source` | Object | `ScrollComponent` | Get tween ScrollComponent |
| `Tween.controller` | Object | `Controller` | Get tween controller |
| `Tween.scene` | Object | `Scene` | Get tween scene |
| `Tween.name` | String | `"."` | Get/Set tween name |
| `Tween.layer` | Object | `Scene.triggerLayer` | Get tween layer |
| `Tween.from` | Object | - | Get tween from properties |
| `Tween.to` | Object | - | Get tween to properties |
| `Tween.options` | Object | `Framer.Defaults.Animation` | Get tween animation options |
| `Tween.init` | Boolean | `true` | Get tween animation initialisation state |
| `Tween.enabled` | Boolean | `true` | Get/Set tween enabled state |
| [`Tween.remove`](#tweenremove) | Method | - | Remove tween |

#### Tween.remove
Remove tween from scene.

##### Parameters:
- `reset` – reset tween

```coffee
# Remove tween
myTween.remove()

# Remove and reset tween
myTween.remove true
```

### Pin
The pin defines what happens in a scene by pinning a defined layer (triggerLayer by default). The pin will pin its layer when its scene starts and unpins its layer when its scene ends if the scene has a duration. Multiple pins can be added on the same layer in the same direction if their scenes are defined in succession.

| Property | Type | Default |  Description |
| :--- | :--- | :--- | :--- |
| `Pin.source` | Object | `ScrollComponent` | Get pin ScrollComponent |
| `Pin.controller` | Object | `Controller` | Get pin controller |
| `Pin.scene` | Object | `Scene` | Get pin scene |
| `Pin.name` | String | `"."` | Get/Set pin name |
| `Pin.layer` | Layer | `Scene.triggerLayer` | Get pin layer |
| `Pin.enabled` | Boolean | `true` | Get/Set pin enabled state |
| `Pin.state` | String | `"pinned"` or `"unpinned"` | Get pin state |
| [`Pin.remove`](#pinremove) | Method | - | Remove pin |

#### Pin.remove
Remove pin from scene.

##### Parameters:
- `reset` – reset pin

```coffee
# Remove pin
myPin.remove()

# Remove and reset pin
myPin.remove true
```

## Known limitations

- It is not recommended to use ScrollController for “clicky” mousewheel scrolling due to the nature of its scrolling behavior.
- Overlapping pins on the same layer in the same direction is not supported, use successive pinning instead.
- Overlapping tweens on the same layer with the same properties is not supported, use successive tweening instead and define `from`, `to` and `init: false` for all but the first tween.
- Removing tweens on a layer with remaining tweens is not supported.

## Releases
- v1.0.1 - Minor optimisations
- v1.0.0 - Initial release

## License
This project is licensed under the [MIT license](LICENSE).

## Author
Developed by Jesper Bentzen.

- Website: [jesperbentzen.com](http://jesperbentzen.com)
- Twitter: [@jbentzen](https://twitter.com/jbentzen)

Star this repository if you like it, and if you find that this plugin somehow saves your day, then consider buying me a coffee via PayPal. It will surely help motivate me to further support this module. :)

## Acknowledgement
A special thank you to [@janpaepke](https://github.com/janpaepke) for creating [ScrollMagic](http://scrollmagic.io) which helped guide the approach used in this module. Also thank you to the entire Framer Slack community and especially [@steveruizok](https://github.com/steveruizok) and [@marckrenn](https://github.com/marckrenn) for sharing their thoughts and hard work to study and build upon.

repository: jbentzen/framer-scrollcontroller

repo_name: jbentzen/framer-scrollcontroller


text:
# JSON codecs

The [JSON entities algebras](/algebras/json-entities.md) show that several options
are available to define endpoints having JSON entities. In this guide, we show
which option should be used in which case, and which interpreters are compatible
with which algebras.

The following diagram summarizes which algebra to use in which case:

~~~ mermaid
graph TB
Doc(Do I want to publish documentation?)-->|yes| JsonSchemaEntities
Doc -->|no| Codec(Do I want to implement both a client and a server?)
Codec -->|yes| JsonEntitiesFromCodec
Codec -->|no| JsonEntities

style JsonSchemaEntities fill:#fff
style JsonEntitiesFromCodec fill:#fff
style JsonEntities fill:#fff
~~~

The first question to ask is “do I want to publish documentation of my
endpoints?”. In order to document the JSON entities of your requests and
responses you need a JSON schema for them, that’s why you have to use the
`JsonSchemaEntities` algebra. See [below](#jsonschemaentities) for more details.

In case you don’t need to document the schema of your JSON entities, the
second question to ask is “do I implement both a client and a server?”.
If this is the case, then you need to be able to both encode and decode
each JSON entity (an entity encoded by the server will be decoded by the
client, and _vice versa_). To ensure that encoders and decoders are consistent
together both have to be provided at the definition site of your endpoints, that’s
why you should use the `JsonEntitiesFromCodec` algebra. See
[below](#jsonentitiesfromcodec) for more details.

Last, if you answered “no” to both questions, then you don’t need to use an algebra,
you can directly use the `JsonEntities` interpreter for your specific client or server.
With this approach, you will have to provide either an encoder or a decoder for each
JSON entity on case-by-case basis: if you implement a client for an endpoint whose
response contains a JSON entity, you will only need a decoder.

The next section reminds general information about the `JsonEntities` hierarchy,
and the remaining sections provide more details on how to use `JsonSchemaEntities`
and `JsonEntitiesFromCodec`.

## The `JsonEntities` hierarchy

The following diagram shows the relations between the three aforementioned algebras,
`JsonEntities`, `JsonEntitiesFromCodec`, and `JsonSchemaEntities`, and their relations
with the other algebras:

![](json-entities.svg)

The `JsonEntities` algebra adds to the `Endpoints` algebra the capability to describe
JSON entities in requests and responses. The `JsonEntitiesFromCodec` algebra refines
the `JsonEntities` algebra by aligning the request and response entities to the same
`JsonCodec` type. Finally, the `JsonSchemaEntities` algebra refines the `JsonEntities`
algebra by aligning the request and response entities to the same `JsonSchema` type.

## `JsonSchemaEntities`

### Algebra

The `JsonSchemaEntities` algebra allows you to define a schema for your JSON entities.
This schema can then be used to derive a documentation (by applying the `endpoints.openapi.JsonSchemaEntities`
interpreter), or codecs (by applying a corresponding interpreter for your JSON library, e.g.
`endpoints.akkahttp.server.circe.JsonSchemaEntities` to use Circe in an Akka HTTP server).

Both the `JsonRequest` and `JsonResponse` types are fixed to the
`JsonSchema` type provided by the [JsonSchemas](/algebras/json-schemas.md) algebra. This means
that you have to define such a `JsonSchema[A]` implicit value (as explained in the `JsonSchemas`
documentation) for each type `A` that you want to carry as a JSON entity.

### Interpreters

To interpret endpoints defined with this algebra, pick an interpreter that matches your
[family](/algebras-and-interpreters.md#interpreters) of interpreters and, if relevant,
the underlying JSON library to use. For instance, the
`endpoints.play.server.circe.JsonSchemaEntities` trait is a server interpreter based
on Play framework that uses the circe JSON library.

## `JsonEntitiesFromCodec`

### Algebra

In case you don’t need to document the JSON schemas of your request and response entities, the
`JsonEntitiesFromCodec` family of algebras is the preferred approach. These algebras fix both
the `JsonRequest` and `JsonResponse` types to a same (abstract) `JsonCodec` type:

~~~ scala src=../../../../../algebras/algebra/src/main/scala/endpoints/algebra/JsonEntities.scala#json-codec-type
~~~

Generally, you want to use a `JsonEntitiesFromCodec` algebra that fixes this `JsonCodec` type to
a concrete type. An example is `endpoints.algebra.playjson.JsonEntitiesFromCodec`, which
aligns the `JsonCodec` type with Play’s `Format` type:

~~~ scala src=../../../../../algebras/algebra-playjson/src/main/scala/endpoints/algebra/playjson/JsonEntitiesFromCodec.scala#type-carrier
~~~

The [JSON entities algebra](/algebras/json-entities.md#jsonentitiesfromcodec) documentation page
shows the list of `JsonEntitiesFromCodec` algebras that fixes the `JsonCodec` type to a concrete type.

### Interpreters

To interpret endpoints defined with such algebras, apply any interpreter named `JsonEntitiesFromCodec`
that matches your [family](/algebras-and-interpreters.md#interpreters) of interpreters. For instance,
if you use interpreters from the `endpoints.xhr` package (ie. the Scala.js web interpreters), you
should use the `endpoints.xhr.JsonEntitiesFromCodec` interpreter.

repository: sullis/endpoints

repo_name: sullis/endpoints


text:
# objectsriptkernel
This is an ObjectScript wrapper kernel for Project Jupyter.

Demo: [http://objectscriptkernel.eastus.cloudapp.azure.com/](http://objectscriptkernel.eastus.cloudapp.azure.com/)

## Inspiration
To make a useful tool for other ObjectScript beginners to learn and easily share info.

## What it does
It allows us to execute ObjectScript inside a Jupyter Notebook.

Great for quick prototyping, teaching, creating business presentations showing IRIS features.

## Challenges I ran into
Almost every step was a new challenge as I've never used either Docker or ObjectScript.

## Accomplishments that I proud of
Finding (well, literally) how to capture ObjectScript console output.

I believe that I get the general gist of it.

## What I learned
How to create Docker files, simple Jupyter wrapper kernels. That ObjectScript can execute its code.

## Built with
Using VSCode and [ObjectScript plugin](https://marketplace.visualstudio.com/items?itemName=daimor.vscode-objectscript) (which is great, by the way), IRIS Community Edition in Docker,
Jupyter in Docker, IRIS Native API for Python

## Installation with Docker

## Prerequisites
Make sure you have [git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git) and [Docker desktop](https://www.docker.com/products/docker-desktop) installed.

Clone/git pull the repo into any local directory e.g. like it is shown below:

```
$ git clone https://github.com/Vekkby/objectsriptkernel.git
```

Open the terminal in this directory and run:

```
$ docker-compose up -d --build
```

## How to Work With it
You may access the notebook server from the browser using
```
localhost:8888
```

There's a sample notebook named 'hello.ipynb' in the 'work' directory.
![alt text](https://i.imgur.com/ualyzhy.gif "Example Notebook")

Just open it and run examples in cells:
![alt text](https://i.imgur.com/42zQpo7.gif "Example Notebook Execution")

repository: PeteOH/objectsriptkernel

repo_name: PeteOH/objectsriptkernel


text:
# ismir-home

Jekyll version of the ISMIR Homepage

## Contributing (the simple version)

In most cases, this website can be updated by the following process:

* fork the website
* make one or more edits
* create a pull request

For minor changes, it may be sufficient to edit the website source (of your fork) *directly in your web browser*. Once your pull request has been approved and merged, the changes will propagate to the live website.

That's it! Simple, right!?

## Contributing Upstream

Not all of the content in this website originates from *this* repository, which is a downstream consumer of three information sources:

- [conference-archive](http://github.com/ismir/conference-archive): Collection of publication metadata
- [mir-datasets](http://github.com/ismir/mir-datasets): Collection of MIR datasets
- Individual conference websites

### Publication Metadata

If you notice that any publication metadata is incorrect, either here or over at [Zenodo](http://zenodo.org), please submit corrections to the [conference-archive](http://github.com/ismir/conference-archive) repository, which maintains the source data for all ISMIR publications.

This is doubly true for missing PDFs. If possible, please provide a URL or upload the PDF in the issue so that we can more easily fix things.

### Datasets

If you would like to add to or update the [list of datasets](http://ismir.net/resources/datasets/) found on this website, please submit corrections to the [mir-datasets](http://github.com/ismir/mir-datasets) repository, which maintains the collection provided here.

### Conference Websites

The websites of past conferences are being migrated to individual repositories in the ISMIR GitHub organization. Each is being served as a separate GitHub pages site, mapped to the corresponding subdomain.

If you find any **major** issues with these websites, please identify the appropriate repository and create an issue (or ideally a pull request!) there. Please note, however, that these websites are provided primarily for historical purposes, and are in a state of critical-issue only maintenance, *e.g.* only significant issues may be addressed (and even then...).

## Developing Locally

This website is written with Jekyll for simplified automatic deployment via GitHub pages. If you are only ever pushing to master, congratulations! this will be rather transparent.

This feedback loop is slow, however, and it is recommended that bigger changes are developed and tested locally. There are a few things to be aware of when doing so:

### Running the Jekyll development server

Make sure you've installed the `jekyll` tools. See the [instructions here](). To serve the website locally, you must be **inside** the `docs` folder, along side the `_config.yaml` file:

```bash
$ cd ./docs
$ jekyll s --port 4000
```

This will not work from the repository root.

### Local configuration

The first pass at developing this site, @ejhumphrey couldn't figure out how to properly use relative URLs in Jekyll across (a) the config file, (b) layout files, and (c) markdown in a way that worked for both local development and as a project site in GitHub, prior to taking over the http://ismir.net domain. This issue is detailed [more completely here](http://github.com/ismir/ismir-home/issues/??).

Until this is fixed more correctly, a temporary solution has been developed where a single field is specified in the site's `_config.yaml`:

```yaml
base_url: /ismir-home
```

When developing locally, set this to an empty string (`""`) for local development. When pushing to master, this should match the repository name (`/ismir-home`).

repository: stefan-balke/ismir-home

repo_name: stefan-balke/ismir-home


text:
---
section-parent: Type theory
section-name: hindley-milner-type-system
---
# Hindley-Milner type-system

- 1. [Introduction](./01-introduction.md)
- 2. [Mono vs polymorphism](./02-mono-vs-polymorphism.md)
- 3. [Let polymorphism](./03-let-polymorphism.md)
- 4. [The definition of the Hindley-Milner type system](04-hm-type-system-definition.md)

## Contents

1. Introduction
2. Monomorphism vs. polymorphism
3. Let-polymorphism
4. The Hindley-Milner type system

  3.1 Syntax
    3.1.1 Monotypes
    3.1.2 Polytypes
    3.1.3 Context and typing
    3.1.4 Free type variables
  3.2 Type order
    3.2.1 Principal type
    3.2.2 Substitution in typings
  3.3 Deductive system
    3.3.1 Typing rules
  3.4 Let-polymorphism
  3.5 Generalization rule
4. An inference algorithm
  4.1 Degrees of freedom choosing the rules
  4.2 Syntax-directed rule system
  4.3 Degrees of freedom instantiating the rules
  4.4 Algorithm J
5. Proving the algorithm
  5.1 Algorithm W
  5.2 Proof obligations
6. Extensions
  6.1 Recursive definitions
    6.1.1 Typing rule
    6.1.2 Consequences
  6.2 Overloading
  6.3 Higher-order types
  6.4 Subtyping
7. References

## Refs

https://en.wikipedia.org/wiki/Hindley-Milner_type_system
https://en.wikipedia.org/wiki/Type_inference

https://stackoverflow.com/questions/12532552/what-part-of-hindley-milner-do-you-not-understand

license: Unlicense


text:
# Composer configurations

## Reference scripts

https://getcomposer.org/doc/articles/scripts.md#referencing-scripts

## Calling composer comands

https://getcomposer.org/doc/articles/scripts.md#calling-composer-commands

Latest versions of composer add a new feature

    "@composer validate"

In previous versions you can use the console command:

    "composer validate"

## Script namespaces

Is posible to use namespace command syntax in scripts.

Examples:

- assets:compile
- assets:clear
- test:php

## Configure bin dir

    {
        "config": {
            "bin-dir": "vendor/bin"
        }
    }

## Configure process timeout

    {
        "config": {
            "process-timeout": 0
        }
    }

## Show comments and blank lines in composer logs

    {
        "scripts": {
            "test": [
                "",
                "# This is a sad comment",
                "# <fg=yellow>This is a happy yellow comment</>",
                "",
            ]
        }
    }

repository: javihgil/composer-ci-tools

repo_name: javihgil/composer-ci-tools


text:
AssemblyInfo
============

Queries the AssemblyInfo of a .NET assembly and formats the output according to you.  This is very useful for things like build scripts.

[Download Latest Release](https://github.com/SaggioTechnologies/AssemblyInfo/releases/)

Usage:

    AssemblyInfo.exe MyAssembly.dll -t "$major.$minor"

Outputs:

    1.2

###Token List
- $major - Major version number
- $minor - Minor version number
- $revision - Revision version number
- $build - Build version number
- $productversion - The full production version
- $informationalversion - The informational version (e.g. 2.3 Hotfix1 or 3.4-rc1)
- $fullname - (MyAssembly, Version=<IP_ADDRESS>, Culture=neutral, PublicKeyToken=de53a01bd32ea25b)

Example:

    AssemblyInfo.exe MyAssembly.dll -t "$fullname"

Outputs:

    MyAssembly, Version=<IP_ADDRESS>, Culture=neutral, PublicKeyToken=de53a01bd32ea25b

Example:

    AssemblyInfo.exe MyAssembly.dll -t "$major.$minor-$revision"

Outputs:

    1.0-3

Example:

    AssemblyInfo.exe MyAssembly.dll -t "$informationalversion"

Outputs:

    3.5-rc1

(works if the assembly has the AssembyInformationalVersion attribute set)

Example (multi-line):

    AssemblyInfo.exe MyAssembly.dll -t "$major.$minor\r\nI like spaghetti"

Outputs:

    1.2
    I like spaghetti

### How to use it in a batch file (like a build script)

    for /f "delims=" %%i in ('AssemblyInfo MyAssembly.dll -t $informationalversion') do set VERSION=%%i
    ECHO %VERSION%

repository: SaggioTechnologies/AssemblyInfo

repo_name: SaggioTechnologies/AssemblyInfo


text:
---
layout: post
title:  "Math -- Numbered Equations"
date:   2020-02-18 08:22:50 -0800
categories: latex
---

In this document, we test MathJax's rendering of LaTeX equations and
the numbering of equations.

# Inline Equations

In the quadratic equation, $$a x^2 + b x + c = 0$$, $$a$$, $$b$$, and
$$c$$ are parameters.

In a summation example, $$\sum_{i=0}^{N} w_i x^i$$, the summation sign
and the limits are compressed in an in-line scenario, compared to a
display scenario.

We take the following examples from the [MathJax
Demos](https://github.com/mathjax/MathJax-demos-web/blob/master/equation-numbers.html) site.

# Equations with numbering
In this document, we test:
 1. if equations are rendered with MathJax.
 1. if the equations are numbered.

General rule for equations:
 * Surround the equation block, whether inline or display, with
   `$$`--both before the block and after the block.  This causes
   kramdown to replace the `$$` with `<script type="math/tex">` tags.
 * In Markdown 2.x, for LaTeX enviroments that do not have a `*`
   (e.g. like in `equation*`), then the `$$` markers are not
   necessary, although they do not harm and could help in cases where
   kramdown may muck with the equation.  This is only for Markdown 2.x.
 * For Markdown 3.0, the `$$` blocks are necessary.
 * In MathJax 3, the `<script type="math/tex">` do not work like they
   do with Markdown 2.x, and we need to insert a script (in the
   layout) to strip these `<script>` tags.

## equation

An `{equation}` enviroment.  Numbered in AMS.

$$
\begin{equation}
E = mc^2
\end{equation}
$$

## equation*

`{equation*}` enviroment.  It won't have an equation number.

$$
\begin{equation*}
E = mc^2
\end{equation*}
$$

### Plain

We can simply surround the display equation with `$$`.  It won't have an equation number.

$$
E = mc^2
$$

### Plain tagged
We add a tag to the plain equation.

$$
E = mc^2  \tag{x}
$$

### Split

Example of a `{split}` environment.

$$
\begin{equation}
\begin{split}
a& =b+c-d\\
& \quad +e-f\\
& =g+h\\
& =i
\end{split}
\end{equation}
$$

## Multline

A `{multiline}` environment.  Numbered in AMS.

$$
\begin{multline}
  a+b+c+d+e+f+g\\
  M+N+O+P+Q\\
  R+S+T\\
  u+v+w+x+y+z
\end{multline}
$$

## Multline*

A `{multline*}` environment.  Not numbered.

$$
\begin{multline*}
  a+b+c+d+e+f+g\\
  M+N+O+P+Q\\
  R+S+T\\
  u+v+w+x+y+z
\end{multline*}
$$

## Gather

A `{gather}` environment.  Each equation gets its own number.  For the
second equation, we have specified `\nonumber`.

$$
\begin{gather}
a_1=b_1+c_1 \\
a_2=b_2+c_2-d_2+e_2 \nonumber \\
a_3 = b_3 + b_3 * c_3^2
\end{gather}
$$

## Gather*

A `{gather*}` environment.

$$
\begin{gather*}
a_1=b_1+c_1\\
a_2=b_2+c_2-d_2+e_2
\end{gather*}
$$

## Align

An `{align}` environment.  Each equation gets its own number.  Second
equation has `\nonumber` specified.

$$
\begin{align}
a_1& =b_1+c_1\\
a_2& =b_2+c_2-d_2+e_2 \nonumber \\
a_3 &= b_3 + c_3^2
\end{align}
$$

### Align with multiple `&` markers

$$
\begin{align}
a_{11}& =b_{11}& a_{12}& =b_{12}\\
a_{21}& =b_{21}& a_{22}& =b_{22}+c_{22}
\end{align}
$$

### Align with `\notag` and `\tag`

The first equation has a `\notag` and the second has `\tag{y}`.

$$
\begin{align}
a_{11}& =b_{11}& a_{12}& =b_{12} \notag \\
a_{21}& =b_{21}& a_{22}& =b_{22}+c_{22} \tag{y}
\end{align}
$$

## Align*

An `{align*}` environment.  Equations are not numbered.

$$
\begin{align*}
a_1& =b_1+c_1\\
a_2& =b_2+c_2-d_2+e_2
\end{align*}
$$

### Align* with `\tag`

$$
\begin{align*}
a_1& =b_1+c_1\tag{z}\\
a_2& =b_2+c_2-d_2+e_2
\end{align*}
$$

repository: jraman/test-jekyll-themes

repo_name: jraman/test-jekyll-themes


text:
---
date: '2005-05-11T01:17:00-04:00'
old:
  layout: post
  oldcategories:
  - freedom
  status: published
  timestamp: 01:17 AM Wednesday, May 11, 2005 EDT
  wordpress_id: '235'
oldtags:
- congress
- freedom
- realID
- stupidity
- terrorism
slug: realid
tags:
- stupidity
- congress
- freedom
- terrorism
- realID
title: 100-0
url: /weblog/2005/05/11/realid/
---

I knew I shouldn't have gotten too excited about us winning the broadcast flag fight.  Today we lost a much more important fight.  The senate voted 100-0 to approve the supplemental funding for Iraq which had a nice rider of the [Real ID act](http://www.unrealid.com/) which will do nothing to make America a safer place.  It just means that now if you're a suspected terrorist not only will you not be able to fly, but you won't be able to get a job, enter a federal building, open a bank account, or really do anything. I'm very sad about our eroding rights as American citizens.

Thanks to all my friends who listened to another one of my crazy calls for action and wrote or faxed senators in Illinois, Pennsylvania, Ohio, Texas, California, and Washington.  I appreciate that all of you were able to see that it was wrong for such an invasive act to be tacked onto a supplementary spending bill for the troops.  I am frankly ashamed that no one even thought to try and remove this part of the bill.  I'm saddened that so many senators who I though were intelligent voted for this bill without piping up.

This is sorta a cheap plug, but for those of you reading this, you may want to check out [GovTrack](http://www.govtrack.us/) for more information (info on this bill is [here](http://www.govtrack.us/congress/bill.xpd?bill=h109-1268)). It's a wonderful site with MASSIVE amounts of information about our government
and also provides lots of different feeds for that information to be sent directly to you.  I use it to track my congress critters and also to track the technology related bills.  Use it.  Keep your congress critters responsible the more people who follow them, the more responsive they'll be.


text:
![OONI Probe](images/OONIProbeLogo.png)

# [Android](https://github.com/ooni/probe-android), [iOS](https://github.com/ooni/probe-ios), [Desktop](https://github.com/ooni/probe-desktop), [CLI](https://github.com/ooni/probe-cli) [![Awesome Humane Tech](https://raw.githubusercontent.com/humanetech-community/awesome-humane-tech/main/humane-tech-badge.svg?sanitize=true)](https://github.com/humanetech-community/awesome-humane-tech)

[Download the desktop app](https://ooni.org/install/desktop)

OONI Probe is free and open source software designed to measure internet
censorship and other forms of network interference.

Every month, thousands of networks are measured by OONI Probe users in [more than 200 countries](https://api.ooni.io/stats). Since 2012, millions of network measurements have been [published](https://ooni.org/data/) from around the world.

OONI Probe is available for the following platforms:

* Android: [probe-android](https://github.com/ooni/probe-android) ([Play Store](https://play.google.com/store/apps/details?id=org.openobservatory.ooniprobe), [F-Droid](https://f-droid.org/repository/browse/?fdid=org.openobservatory.ooniprobe))
* iOS: [probe-ios](https://github.com/ooni/probe-ios) ([App Store](https://itunes.apple.com/us/app/id1199566366))
* Desktop App: [probe-desktop](https://github.com/ooni/probe-desktop)
* Command Line tool: [probe-cli](https://github.com/ooni/probe-cli)

OONI Probe tests are implemented in Go in [github.com/ooni/probe-cli](https://github.com/ooni/probe-cli).

OONI Probe tests the lists of websites included in the [citizenlab/test-lists repository](https://github.com/citizenlab/test-lists/).

OONI Probe *used* to be written in python. The legacy python version of OONI Probe is available here: [probe-legacy](https://github.com/ooni/probe-legacy).

To learn more about OONI, check out our website: https://ooni.org/

repository: ooni/probe

repo_name: ooni/probe


text:
---
title: Configuration system failed to initialize
slug: ConfigurationSystemError
publish: true
position: 4
---

#### Fiddler Classic crashes on startup complaining about the "Configuration System":

		Sorry, you may have found a bug...

		Fiddler has encountered an unexpected problem. If you believe this is a bug in Fiddler, please copy this message by hitting CTRL+C, and submit a bug report using the Help | Send Feedback menu.
		Configuration system failed to initialize
		Source: System.Configuration
		at System.Configuration.ConfigurationManager.PrepareConfigSystem()
		at System.Configuration.ConfigurationManager.GetSection(String sectionName)

		System.Configuration.ConfigurationErrorsException: Unrecognized configuration section system.serviceModel. (c:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\Config\machine.config line 134)
		or

		System.Configuration.ConfigurationErrorsException: Unrecognized configuration section runtime. (C:\Program Files (x86)\Fiddler2\Fiddler.exe.Config line 2)

This error message indicates that one of the .NET Framework's configuration files is corrupt. The most common fix for this is to visit WindowsUpdate and install all available .NET Framework updates. If that doesn't work, try re-installing the .NET Framework. If that doesn't work, try editing the file specified in the error message to correct whatever the error message is complaining about.

repository: telerik/fiddler-docs

gha_language: Ruby

repo_name: telerik/fiddler-docs


text:
---
title: "Python"
metaTitle: "GraphQL Server with Python | Backend Tutorial"
metaDescription: "In this tutorial, learn how to integrate Python in a GraphQL backend server stack with Hasura"
---

## GraphQL server with Python

Python is a programming language that lets you work quickly and integrate systems more effectively. Learn more at [the official website](https://www.python.org/).

The following guide covers common backend application tasks, such as creating REST endpoints using [FastAPI](https://fastapi.tiangolo.com/). We also go over how to integrate your Python app with Hasura.

> New to GraphQL? Check out the [Introduction to GraphQL](https://hasura.io/learn/graphql/intro-graphql/introduction/) tutorial to learn the core concepts quickly.

- You will learn how to create a GraphQL server with Python and Strawberry FastAPI.
- If you have an existing GraphQL API with Python, you can integrate it with Hasura as a [Remote Schema](https://hasura.io/docs/latest/remote-schemas/index/) to get a unified GraphQL API.
- If you have an existing REST API with Python, you can transform that declaratively to GraphQL without writing any code using [Hasura REST Connectors](https://hasura.io/docs/latest/actions/rest-connectors/).
- You can also re-use or custom write REST endpoints with Python and map the endpoint to a GraphQL schema in Hasura.

> New to Hasura? The Hasura GraphQL Engine makes your data instantly accessible over a real-time GraphQL API so that you can build and ship modern, performant apps and APIs 10x faster. Hasura connects to your databases, REST and GraphQL endpoints, and third-party APIs to provide a unified, connected, real-time, secured GraphQL API for all your data. Check out the [Hasura documentation](https://hasura.io/docs/latest/index/).

## Create a Python GraphQL Server with Strawberry

We can make a custom GraphQL server in Python using [Strawberry](https://strawberry.rocks/) and connect it to Hasura using a [remote schema](https://hasura.io/docs/latest/graphql/core/remote-schemas/index/).

1. Run the [Strawberry FastAPI quickstart](https://strawberry.rocks/docs/integrations/fastapi)

2. In `remoteSchema/remoteSchema.py` add the Strawberry code

   ```python
   import strawberry
   from strawberry.fastapi import GraphQLRouter

   @strawberry.type
   class Query:
       @strawberry.field
       def hello(self) -> str:
         return "Hello World"

   schema = strawberry.Schema(Query)

   graphql_app = GraphQLRouter(schema)
   ```

3. Add the generated GraphQL handler to `main.py`

   ```python
   from remoteSchema.remoteSchema import graphql_app

   app.include_router(graphql_app, prefix="/graphql")
   ```

### Python GraphQL API Federation using Hasura Remote Schema

We can connect our custom GraphQL server to Hasura using [remote schemas](https://hasura.io/docs/latest/graphql/core/remote-schemas/index/) to unify the GraphQL endpoint as a single endpoint.

1. In the Hasura Console remote schema tab, add your Python server `<Python server URL>/graphql`

2. In the API Explorer tab, try querying the sample todos.

   ```graphql
   {
     hello
   }
   ```

## Convert a Python REST API endpoint to GraphQL

In this section, we will write a REST Endpoint in Python using FastAPI and see how to transform that to GraphQL. We will create a login POST endpoint that takes a username and password and returns an access code.

In our `main.py`, we use FastAPI to create an HTTP server:

```python
from fastapi import FastAPI
from typing import Generic, TypeVar
from pydantic import BaseModel
from pydantic.generics import GenericModel
from action.loginTypes import LoginResponse, loginArgs
from event.event import Payload
from remoteSchema.remoteSchema import graphql_app
from qlient.aiohttp import AIOHTTPClient, GraphQLResponse

ActionInput = TypeVar("ActionInput", bound=BaseModel | None)

class ActionName(BaseModel):
    name: str

class ActionPayload(GenericModel, Generic[ActionInput]):
    action: ActionName
    input: ActionInput
    request_query: str
    session_variables: dict[str, str]

app = FastAPI()

@app.post("/action")
async def actionHandler(action: ActionPayload[loginArgs]) -> LoginResponse:
    action.input
    return LoginResponse(AccessToken="<sample value>")
```

In `action/action.py`, we create the handler:

```python
from enum import Enum, auto
from pydantic import BaseModel

class LoginResponse(BaseModel):
    AccessToken: str

class Mutation(BaseModel):
    login: LoginResponse | None

class loginArgs(BaseModel):
    username: str
    password: str
```

Install the dependencies and run the app

```bash
pip install "fastapi[all]"

uvicorn main:app --reload
```

### Add Python REST Endpoint to GraphQL schema using Hasura Actions

When writing a backend we usually have to write around 80% of our code doing boilerplate CRUD operations. Hasura helps us by autogenerating this part.

When we need to write custom business logic we can integrate our Python REST endpoint using [Hasura Actions](https://hasura.io/docs/latest/actions/index/), giving us the best of both worlds.

In the Actions tab on the Hasura Console we will set up a custom login function that calls the REST endpoint we created:

```graphql
type Mutation {
  login(username: String!, password: String!): LoginResponse
}
```

New types definition:

```graphql
type LoginResponse {
  AccessToken: String!
}
```

Create the action, click the `Codegen` tab, and select `python-fast-api`.

Copy `login.py` to `main.py` and `loginTypes.py` in your project.

In the Hasura API explorer tab you should now be able to test it

```graphql
mutation {
  login(password: "password", username: "username") {
    AccessToken
  }
}
```

Result:

```json
{
  "data": {
    "login": {
      "AccessToken": "<sample value>"
    }
  }
}
```

### Run async scheduled events using a Python REST API and Hasura GraphQL

Databases like Postgres can run triggers when data changes, with [Hasura event triggers](https://hasura.io/docs/latest/event-triggers/index/) we can easily call an HTTP endpoint whenever we have one of these events.

Let's send a webhook when a new user is created and print out their name.

1.  In the Hasura Console add a `user` table with a `Text` column `name` and the frequently used `UUID` column id.

2.  In the event trigger tab, on the `user` table, check the insert and via console trigger operations.

3.  The event trigger payload schema can be found [in the docs](https://hasura.io/docs/latest/graphql/core/event-triggers/payload/#json-payload). We make pydantic classes in Python to represent this

    ```python
    from pydantic import BaseModel, Field
    from pydantic.generics import GenericModel
    from typing import Generic, Literal, TypeVar

    New = TypeVar("New", bound=BaseModel | None)
    Old = TypeVar("Old", bound=BaseModel | None)

    class DeliveryInfo(BaseModel):
        current_retry: int
        max_retries: int

    class Data(GenericModel, Generic[New, Old]):
        new: New
        old: Old

    class TraceContext(BaseModel):
        span_id: str
        trace_id: str

    class Event(GenericModel, Generic[New, Old]):
        data: Data[New, Old]
        op: Literal["INSERT", "UPDATE", "DELETE", "MANUAL"]
        session_variables: dict[str, str]
        trace_context: TraceContext

    class Table(BaseModel):
        name: str
        schema_: str = Field("", alias="schema")

    class Trigger(BaseModel):
        name: str

    class Payload(GenericModel, Generic[New, Old]):
        created_at: str
        delivery_info: DeliveryInfo
        event: Event[New, Old]
        id: str
        table: Table
        trigger: Trigger

    ```

4.  Now we make an HTTP handler that handles the event

    ```python
    from event import Payload
    class UserTable(BaseModel):
      id: str
      name: str

    @app.post("/event")
    async def actionHandler(action: Payload[UserTable, None]):
        return
    ```

When you add a user in Hasura your Python server should receive the event.

## Example: Querying GraphQL with Python Client qlient

To query a GraphQL endpoint from Python we use the async version of [qlient](https://github.com/qlient-org/python-qlient).

1. Install qlient

   ```bash
   pip install qlient.aiohttp
   ```

2. Query all users in the event trigger handler we created earlier,

   ```python
   @app.post("/event")
   async def actionHandler(action: Payload   [UserTable, None]):
       async with AIOHTTPClient("http://localhost:8080/v1/graphql") as client:
           result: GraphQLResponse = await client.query.user(["id", "name"])
           print(result.request.query)
           print(result.data)
       return
   ```

## Summary

When developing backend applications, we may need to write custom business logic. When we use Hasura, it autogenerates most of our API but gives us escape hatches for this custom logic. We've gone over a few ways you can use the power of Python.

See the [server source code on Github](https://github.com/hasura/learn-graphql/tree/master/tutorials/backend/backend-stack/source-code/python).

If you use Hasura and are ready to go to production, check out Hasura Cloud for a fully managed Hasura deployment.

repository: hasura/learn-graphql

gha_language: JavaScript

repo_name: hasura/learn-graphql


text:
# eospy library

This library is still a work in progress but currently has the ability to perform all `cleos get` functions without compiling the code.

The library now supports signing transactions/key creation for both python 2.7 and 3.x. This is the first iteration and is very rough. The key creation has not been tested fully and should be used at your own risk.

The cleos commands currently implemented.
```
Usage: /usr/local/bin/cleos get SUBCOMMAND

Subcommands:
  get
    info                        Get current blockchain information
    block                       Retrieve a full block from the blockchain
    account                     Retrieve an account from the blockchain
    code                        Retrieve the code and ABI for an account
    abi                         Retrieve the ABI for an account
    table                       Retrieve the contents of a database table
    currency                    Retrieve information related to standard currencies
    accounts                    Retrieve accounts associated with a public key
    servants                    Retrieve accounts which are servants of a given account
    transaction                 Retrieve a transaction from the blockchain
    actions                     Retrieve all actions with specific account name referenced in authorization or receiver
  system
    newaccount                  Create an account, buy ram, stake for bandwidth for the account
```

This library is very much a work in progress.

## Installation

### Linux
```
# create virtual environment
mkdir -p ~/envs/eospy
virtualenv ~/envs/eospy
# activate the environment
source ~/envs/eospy/bin/activate
# install the library
pip install git+https://github.com/eosnewyork/eospy
```

### Windows

1. Install python
You can use either Python 2.7 or 3.7 however we suggest python 3.7 as we have tested that version more thoroughly.
https://www.howtogeek.com/197947/how-to-install-python-on-windows/
[Python 2.7](https://www.python.org/downloads/release/python-2715/)
[Python 3.7](https://www.python.org/downloads/release/python-370/)

2. Install git
https://www.atlassian.com/git/tutorials/install-git

3. Install eospy
```
pip install git+https://github.com/eosnewyork/eospy
```

## API Endpoints
For a more complete list of API endpoints check out:

https://www.eosdocs.io/resources/apiendpoints/

## Command line Tool Examples
```
# Get chain information
pycleos --url https://api.eosnewyork.io get info

# get information about a block
pycleos --url https://api.eosnewyork.io get block 447

# Retrieve an account from the blockchain
pycleos --url https://api.eosnewyork.io get account --account eosio

# Retrieve the code and ABI for an account
pycleos --url https://api.eosnewyork.io get code --account eosio

# Retrieve the ABI for an account
pycleos --url https://api.eosnewyork.io get abi --account eosio

# Retrieve the contents of a database table
pycleos --url https://api.eosnewyork.io get table --code eosio --scope eosio --table producers

# Retrive currency information
pycleos --url https://api.eosnewyork.io get currency balance --code eosio.token --symbol EOS --account aaaaaaaaaaaa
pycleos --url https://api.eosnewyork.io get currency stats --code eosio.token --symbol EOS

# get accounts associated with public key
pycleos --url https://api.eosnewyork.io get accounts --key EOS52gpRqAPfggYHLXbMuC4TSQd8WWWo94KrMq4umgUcjM62Y2dWF

# get transaction information
pycleos --url https://api.eosnewyork.io get transaction --transaction 42dacd5722001b734be46a2140917e06cd21d42425f927f506c07b4388b07f62

# get account actions
pycleos --url https://api.eosnewyork.io get actions --account aaaaaaaaaaaa

```

## Examples

Check out the examples directory for some examples of how to use the library

repository: unification-com/haiku-node-prototype

gha_language: Python

repo_name: unification-com/haiku-node-prototype


text:
# Password Locker

The password manager program you’ll create in this example isn’t secure, but it offers a basic demonstration of how such programs work.

This script can be run with a command line argument that is the account's name (for example, email or blog). The password associated with the account will be copied to the clipboard so that the user can paste it into a Password field.

This script demonstrates how to automate the retrieval of commonly referenced text.

## Sample Output

repository: KFOAS/automate-the-boring-stuff

repo_name: KFOAS/automate-the-boring-stuff


text:
---
layout: page
title: string
category: type
description: character sequence
---

# `{{ page.title }}`

Strings in Jai are sequences of zero-terminated unsigned 8-bit characters.

### Examples

Iterate over string and alter characters:

{% include collapsible_example.liquid file='code/nine_to_five.jai' syntax='cpp' %}

repository: pixeldroid/jailang

repo_name: pixeldroid/jailang