text:
# isf [![Build Status](https://travis-ci.org/nannou-org/isf.svg?branch=master)](https://travis-ci.org/nannou-org/isf) [![Crates.io](https://img.shields.io/crates/v/isf.svg)](https://crates.io/crates/isf) [![Crates.io](https://img.shields.io/crates/l/isf.svg)](https://github.com/nannou-org/isf/blob/master/LICENSE-MIT) [![docs.rs](https://docs.rs/isf/badge.svg)](https://docs.rs/isf/)

Parsing, deserialization and serialization of ISF - the Interactive Shader Format.

Implementation is as described under "The ISF Specification Vsn 2.0" part of [the spec site](https://www.interactiveshaderformat.com/spec).

The [**parse**](https://docs.rs/isf/latest/isf/fn.parse.html) function can parse
a given GLSL string to produce an
[**Isf**](https://docs.rs/isf/latest/isf/struct.Isf.html) instance. The **Isf**
type represents a fully structured representation of the format, including typed
[**Input**](https://docs.rs/isf/latest/isf/struct.Input.html)s.

## Tests

The repo includes all shaders from the "ISF Test/Tutorial filters" collection
provided by the specification site along with all shaders within the
["Vidvox/ISF-Files" repository](https://github.com/Vidvox/ISF-Files) for
automated testing. These tests do a full roundtrip on every shader in the
following steps:

1. Read the GLSL string from file.
2. Parse the GLSL string for the top-level dictionary.
3. Deserialize the JSON to an `Isf` struct.
4. Serialize the `Isf` struct back to a JSON string.
5. Deserialize the new JSON string to an `Isf` struct again.
6. Assert the first `Isf` instance is identical to the second.

Thanks to the Vidvox crew for allowing us to include these tests in the repo for
easy automated testing!

## Example

Parsing a GLSL string to an ISF struct looks like this:

```rust
let isf = isf::parse(&glsl_str).unwrap();
```

See the [`Isf` struct docs](https://docs.rs/isf/latest/isf/struct.Isf.html) to
get an idea of what you can do with it!

Here's a copy of the `tests/roundtrip.rs` test as described above:

```rust
let test_files_path = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("test_files");
assert!(test_files_path.exists());
assert!(test_files_path.is_dir());
for entry in std::fs::read_dir(test_files_path).unwrap() {
    let entry = entry.unwrap();
    let path = entry.path();
    let ext = path.extension().and_then(|s| s.to_str());
    if ext == Some("fs") || ext == Some("vs") {
        let glsl_str = std::fs::read_to_string(&path).unwrap();
        let isf = match isf::parse(&glsl_str) {
            // Ignore non-ISF vertex shaders.
            Err(isf::ParseError::MissingTopComment) if ext == Some("vs") => continue,
            Err(err) => panic!("err while parsing {}: {}", path.display(), err),
            Ok(isf) => isf,
        };
        let isf_string = serde_json::to_string_pretty(&isf).unwrap();
        let isf2 = serde_json::from_str(&isf_string).unwrap();
        assert_eq!(isf, isf2);
    }
}
```

## About

This crate has been developed as a step towards creating an ISF live-coding
environment based on [**nannou**](https://nannou.cc), the creative coding
framework.

repository: nannou-org/isf

repo_name: nannou-org/isf


text:
# Styling Google Maps <!-- omit in toc -->
- [Custom Styles](#custom-styles)
- [Using a tool and a separate file for the styles](#using-a-tool-and-a-separate-file-for-the-styles)
- [Markers](#markers)
  - [Adding an removing markers dynamically](#adding-an-removing-markers-dynamically)
  - [Adding multiple markers in one go](#adding-multiple-markers-in-one-go)
- [Finding coordinates](#finding-coordinates)
- [Info windows](#info-windows)
  - [Snazzy Info Window](#snazzy-info-window)
- [Drawing shapes](#drawing-shapes)
- [Overlays](#overlays)
## Custom Styles

You can change the colour of map elemens by passing a style option when you create the map. The following example changes the colour
of the water and its labels. Try this in your *Home.vue* file inside the *mounted* function which should be there already.

```javascript
  mounted: function(){
    const element = document.getElementById("map")
    const styles =
    [
    {
      featureType: 'water',
      elementType: 'geometry',
      stylers: [{color: '#f39dde'}]
    },
    {
      featureType: 'water',
      elementType: 'labels.text',
      stylers: [{color: '#9e9e9e'}]
    }
    ];

    const options = {
        zoom: 14,
        center: new google.maps.LatLng(47.071467, 8.277621),
        styles: styles
    };

    this.map = new google.maps.Map(element, options);
  }
```
![styled map](/public/styles.png)

The colours in this example are set in hexadecimal format, indicated by the #. You can use a tool to help find the colour codes, for example [this one by Mozilla](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Colors/Color_picker_tool). But there are many others that you can find with a quick search.

Possible features that you can style are
* all
* administrative
* poi
* road
* transit
* water

Possible elements to style are
* all (default)
* geometry
  * geometry.fill
  * geometry.stroke
* labels
  * labels.text
    * labels.text.fill
    * labels.text.stroke
  * labels.icon

You can find more details in [the maps documentation](https://developers.google.com/maps/documentation/javascript/style-reference).

## Using a tool and a separate file for the styles
Google Maps offers [a tool](https://mapstyle.withgoogle.com/) to help with styling.

![map styling tool](/public/tool.png)

This will generate the styles for your. The code that is generated is quite long. We could just replace lines 12 to 22 in the example above with the generated code. However, this will make the code a bit hard to read. That is why we move that code to a separate file and import it.
* In the folder *src* create a file named *style.js*
* Copy the code from the tool into a variable named *mystyle* so that it looks like this.
```javascript
let mystyle = [
    {
      "elementType": "geometry",
      "stylers": [
        {
          "color": "#f5f5f5"
        }
      ]
    },
...
    }
  ];
```
* Export the *mystyle* variable by adding the following line to the file
```javascript
export default mystyle;
```
* Import the new file in *Home.vue*
```javascript
<script>
// @ is an alias to /src
import HelloWorld from<EMAIL_ADDRESS>import mystyle from<EMAIL_ADDRESS>```
* Use the new style
```javascript
   mounted: function(){
    const element = document.getElementById("map")

    const options = {
        zoom: 14,
        center: new google.maps.LatLng(47.071467, 8.277621),
        styles: mystyle
    };

    this.map = new google.maps.Map(element, options);
  }
```

## Markers
Markers are documente [here](https://developers.google.com/maps/documentation/javascript/markers).
To add a default marker use the following code inside the *mounted* function, but after you have created the map.
```javascript
    let marker = new google.maps.Marker({
        position: {lat: 47.070978, lng: 8.282165},
        map: this.map
    });
```

![marker](/public/marker.png)

You can add your own custom icon to a marker by providing a URL for an image.
```javascript
    let marker = new google.maps.Marker({
        position: {lat: 47.070978, lng: 8.282165},
        icon: 'http://icons.iconarchive.com/icons/iconsmind/outline/64/Bicycle-icon.png',
        map: this.map
    });
```

![custom marker](/public/custom.png)

You can also create your own icon and store in the *public* folder. Then, you don't need to provide the full path.
```javascript
    let marker = new google.maps.Marker({
        position: {lat: 47.070978, lng: 8.282165},
        icon: 'myicon.png',
        map: this.map
    });
```

### Adding an removing markers dynamically
Use the `setMap` function to add a marker to a map dynamically.
```javascript
marker.setMap(this.map);
```
To remove the marker, pass in `null` as an argument.
```javascript
marker.setMap(null);
```

### Adding multiple markers in one go
You can add multiple markers with different locations like this:
```javascript
const locations = [
  {lat: 47.071978, lng: 8.262165 },
  {lat: 47.072978, lng: 8.292165 },
  {lat: 47.073978, lng: 8.292165 },
  {lat: 47.074978, lng: 8.282165 }
];
let markers = [];
  locations.map(loc => {
  markers.push(new google.maps.Marker({
     position: {lat: loc.lat, lng: loc.lng},
     map: this.map
  }));
});
```

## Finding coordinates
To find the coordinate of a location, open Google Maps. Right click on the location and choose *What's here?* from the menu.
![Finding coordinates on a map](/public/coordinates.PNG)

## Info windows
Info windows can show more information on a location, for example, after a marker has been clicked. They are documented [here](https://developers.google.com/maps/documentation/javascript/infowindows).

![Info window](/public/infowindow.png)

Define the content of an info window.
```javascript
const contentString = `<div>
  <h1>Mein Titel</h1>
  <div>Mein Text...</div>
</div>`
let infowindow = new google.maps.InfoWindow({
  content: contentString
});
```
Tie it to a marker so that it opens when the marker is clicked.
```javascript
    marker.addListener('click', event => {
      infowindow.open(this.map, marker);
    });
```
You can add CSS styles to the info window.
```javascript
const contentString = `<div>
  <h1 style="color: blue">Mein Titel</h1>
  <div>Mein Text...</div>
</div>`
```

### Snazzy Info Window
To create a more customized info window, you can use a libary like [Snazzy Info Window](https://github.com/atmist/snazzy-info-window). To add it to this project, do the following steps.
* Install the libary from npm: $ npm install snazzy-info-window -- save
* Import it into *Home.vue*
```javascript
import SnazzyInfoWindow from 'snazzy-info-window'
```
* Import the styles globally inside *App.vue*
```javascript
<style lang="scss">
@import '../node_modules/snazzy-info-window/dist/snazzy-info-window.scss';
```
* Follow the instructions on the Snazzy website to use the library.

## Drawing shapes
You can draw [lines](https://developers.google.com/maps/documentation/javascript/shapes#polylines) and [shapes](https://developers.google.com/maps/documentation/javascript/shapes#polygons) onto the map.
To draw a set of connected lines (a polyline), use the following code.
```javascript
const plcoords = [
  {lat: 47.071978, lng: 8.262165 },
  {lat: 47.072978, lng: 8.292165 },
  {lat: 47.073978, lng: 8.292165 },
  {lat: 47.074978, lng: 8.282165 }
];
let polyline = new google.maps.Polyline({
  path: plcoords,
  strokeColor: '#FF0000',
  strokeOpacity: 1.0,
  strokeWeight: 2,
  map: this.map
});
```
![Polyline](/public/line.png)

Using the same coordinate from above, we can also create a polygon.
```javascript
let polygon = new google.maps.Polygon({
  path: plcoords,
  strokeColor: '#4286f4',
  strokeOpacity: 1.0,
  strokeWeight: 2,
  fillColor: '#FF0000',
  fillOpacity: 0.35,
  map: this.map
});
```
![Polygon](/public/polygon.png)

## Overlays
You can overlay images onto the map. Follow [the instructions](https://developers.google.com/maps/documentation/javascript/examples/groundoverlay-simple)

![Overlay](/public/overlay.png)

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
https://cultureportalteam31architects.netlify.com/

# leonidshparun
| time spent  | feature |
| ------------| ----- |
| 2h  | Project structure  |
| 1h  | Team page  |
| 1h  | Developer card  |
| 1h  | Timeline component  |
| 1h  | Author card component  |

# annaloiko
| time spent  | feature |
| ------------| ----- |
| 2h  | youtube-modal video   |
| 2h  | architect of the day  |
| 3h  | design styles |
| 3h  | responsive navigation  |

# strafi
| time spent  | feature |
| ------------| ----- |
| 3h  | create contentful DB   |
| 2h  | search vidget  |
| 1h  | optimize graphql queries |
| 30min  | architect page base  |
| 1h  | style list of architects  |
| 7h | translation  |

# matveykorbut
| time spent  | feature |
| ------------| ----- |
| 1h  | gatsby config   |
| 1h  | ArchitectList  |
| 2h  | newPage + gatsby-node |
| 2h  | Map component  |
| 30min | Map component refactor  |
| 30min | Netlify + Contentful  |
| 10min | Activity component  |
| 1h  | Netlify app  |

# msv1990
| time spent  | feature |
| ------------| ----- |
| 2h  | gallery slider   |
| 1h  | gallery styles |

Points - **240/240**

### Min scope - **40**
- [X] **10** Main page + page with a list of authors + author's page (only html);
- [X] **10** Page with list of authors contains search widget;
- [X] **20** Portal has two languages;

### Normal scope - **130**
- [X] **10** Author's page contains timeline;
- [X] **10** Author's page contains video overlay;
- [X] **20** Author's page contains photo gallery;
- [X] **10** Author's page contains map (geowidget);
- [X] **from 10 to 40** Project is made using react (max 40 - if all widgets are done in React);
- [X] **from 0 to 20** Design;
- [X] **20** material-ui / bootstrap is used

### Extra scope - **70**
- [X] **10** Confidence of the project presentation;
- [X] **30** Project is made using gatsbyjs;
- [X] **20** contentful / netlify cms is used for content management
- [X] **10** Portal has third language;

repository: MatveyKorbut/Culture-portal

gha_language: JavaScript

gha_license_id: MIT

repo_name: MatveyKorbut/Culture-portal


text:
# *Digital-electronics-1.*

# *Labs DE1*

# *03-Vivado*

## Task 1. Table and schematics with connection of 16 slide switches and 16 LEDs on Nexys A7 board

| **Switch number** | **Switch pin** | **LED number** | **LED pin** |
| :-: | :-: | :-: | :-: |
| 0 | J15 | 0 | H17 |
| 1 | L16 | 1 | K15 |
| 2 | M13 | 2 | J13 |
| 3 | R15 | 3 | N14 |
| 4 | R17 | 4 | R18 |
| 5 | T18 | 5 | V17 |
| 6 | U18 | 6 | U17 |
| 7 | R13 | 7 | U16 |
| 8 | T8 | 8 | V16 |
| 9 | U8 | 9 | T15 |
| 10 | R16 | 10 | U14 |
| 11 | T13 | 11 | T16 |
| 12 | H6 | 12 | V15 |
| 13 | U12 | 13 | V14 |
| 14 | U11 | 14 | V12 |
| 15 | V10 | 15 | V11 |

![Switch_&_LED_connection](Images/SWs_LEDs.png)

--------------
## Task 2. Two-bit wide 4-to-1 multiplexer

### Listing of VHDL architecture from source file mux_2bit_4to1.vhd with syntax highlighting
```VHDL
architecture Behavioral of mux_2bit_4to1 is
begin

	f_o <= a_i when (sel_i = "00") else
	       b_i when (sel_i = "01") else
	       c_i when (sel_i = "10") else
           d_i;

end architecture Behavioral;
```

### Listing of VHDL stimulus process from testbench file tb_mux_2bit_4to1.vhd with syntax highlighting
```VHDL
p_stimulus : process
    begin
        -- Report a note at the begining of stimulus process
        report "Stimulus process started" severity note;

        s_d <= "00"; s_c <= "00"; s_b <= "00"; s_a <= "00";
        s_sel <= "00"; wait for 100 ns;

        s_a   <= "01"; wait for 100 ns;
        s_b   <= "01"; wait for 100 ns;
        s_sel <= "01"; wait for 100 ns;

        s_c   <= "01"; wait for 100 ns;
        s_b   <= "11"; wait for 100 ns;

        s_d <= "11"; s_c <= "01"; s_b <= "00"; s_a <= "10";
        s_sel <= "10"; wait for 100 ns;

        s_d <= "00"; s_c <= "10"; s_b <= "01"; s_a <= "11";
        s_sel <= "11"; wait for 100 ns;

        s_d <= "01"; s_c <= "11"; s_b <= "00"; s_a <= "10";
        s_sel <= "01"; wait for 100 ns;

        -- Report a note at the end of stimulus process
        report "Stimulus process finished" severity note;
        wait;
    end process p_stimulus;
```

### Screenshot with simulated time waveforms

![2bit_4to1_multiplexer_waveforms](Images/Waveforms.png)

## Task 3. A Vivado tutorial

**Welcome to my Vivado tutorial lads!**
Today we will learn about basics of using **Vivado** program made by **Xilinx, Inc.**
This program is made for synthesis and analysis of HDL and today i will show you how to start with Vivado

## Making of new project in Vivado
**1.** After opening Vivado click under **Quick Start** choose **Create Project**.

--------------
--------------
--------------
--------------
--------------
--------------
--------------
--------------
--------------
--------------
--------------
--------------

**2.** A wizard open up and on the second window you name your project and location where your project will be saved at.

--------------
**3.** After you continue on the third window you choose **RTL Project**.

--------------
**4.** Then on the next window program asks you if you want to make a new source file. Either you can do it here by clicking on **Create File** or you can do it later in the project itself.

--------------
**5.** Lets suppose you want to create the source now so you click on the **Create File** and small window show up and there you enter the source file name (Lets be honest it is very helpful if you name your sources like the name of your project) and click **OK** and then **Next**.

--------------
**6.** The same you can do on the next window but this time for constraints file.

**7.** Then you choose Part or Boards. Lets suppose you choose boards so you click on the item **Boards** and there you choose one of the boards.

--------------
**8.** Then after clicking **Next** you will see a summary of your project and if you are satisfied with the options you have made you click on **Finish** button.

--------------
## Source files and testbench file
**1.** When your project load up (be patient, it can take a minute) you can add more source files or simulation files by clicking on **File** in the left up corner and then you click on **Add sources**

**2.** A window pop up where you can choose if you want design source, simulation source (we call it testbench and its needed to contain conditions for the simulation, so make one of the testbench files) and then constraints file.

**3.** When we made desigh source and simulation source we can start writing code.

--------------
--------------
## Simulation
**1.** After we are done writing the code in our desigh and testbench files we click the ** Run Simulation** button on the left and we choose **Run .... Simulation** (depends on what we are programming)

--------------
**2.** The simulation opens and you can see waveforms. If there is some error in the waveforms try to choose other radix

--------------
--------------
--------------
--------------
--------------
--------------
**3.** Then you can zoom simulation to fit the screen by clicking **Button with four arrows** and you can also change the color of the waves.

--------------
**4.** For better understanding of the waveforms you can put a cursors on the waves

--------------
**Thats all for my simple Vivado tutorial. Have a nice day.**

branch_name: refs/heads/main


text:
## Algorithmic Methods of Data Mining - Homework 1

Please find in this repository the following files:
1. `README.md`: a Markdown file that explains the content of the repository
1. `stamps/`: a folder with the screenshots of the submissions from the *hackerrank* site
2. `scripts.py`: a .py file with the solutions of the exercices


text:
---
layout: post
title: 2013 Annual Coop Report
comments: true
---

In April all of the students in the [Arkansas Cooperative Fish and Wildlife Research Unit](http://www.coopunits.org/Arkansas/) presented to our cooperators on our projects for the 2013 fiscal year. Its a great way for all of us get feedback and make sure that our projects are still answering the questions that started the projects.

Part of this meeting every year is our annual report, which you can read [here](https://s3.amazonaws.com/file-storage.DEPARTMENT-ACTIVITIES.digitalmeasures.usgs.edu/arkansas/unit_docs/2013%20Annual%20Report%20Complete-1.pdf). Between all 12 of us we work on everything from water flow regimes, crayfish, bass, mice, turkeys, rails, geese and many things in between.


text:
# Module: WaitForConditions

**`export`**

**`namespace`** WaitForConditions

## Properties

### `Optional` count

• **count**? : *number*

*Defined in [src/generated/api.ts:2373](https://github.com/mailslurp/mailslurp-client-ts-js/blob/507ad2d/src/generated/api.ts#L2373)*

Number of results that should match conditions. Either exactly or at least this amount based on the `countType`. If count condition is not met and the timeout has not been reached the `waitFor` method will retry the operation.

**`type`** {number}

**`memberof`** WaitForConditions

___

### `Optional` countType

• **countType**? : *[CountTypeEnum](../enums/_generated_api_.waitforconditions.counttypeenum.md)*

*Defined in [src/generated/api.ts:2379](https://github.com/mailslurp/mailslurp-client-ts-js/blob/507ad2d/src/generated/api.ts#L2379)*

How should the found count be compared to the expected count.

**`type`** {string}

**`memberof`** WaitForConditions

___

### `Optional` inboxId

• **inboxId**? : *string*

*Defined in [src/generated/api.ts:2385](https://github.com/mailslurp/mailslurp-client-ts-js/blob/507ad2d/src/generated/api.ts#L2385)*

ID of inbox to search within and apply conditions to. Essentially filtering the emails found to give a count.

**`type`** {string}

**`memberof`** WaitForConditions

___

### `Optional` matches

• **matches**? : *Array‹[MatchOption](_generated_api_.matchoption.md)›*

*Defined in [src/generated/api.ts:2391](https://github.com/mailslurp/mailslurp-client-ts-js/blob/507ad2d/src/generated/api.ts#L2391)*

Conditions that should be matched for an email to qualify for results. Each condition will be applied in order to each email within an inbox to filter a result list of matching emails you are waiting for.

**`type`** {Array<MatchOption>}

**`memberof`** WaitForConditions

___

### `Optional` sortDirection

• **sortDirection**? : *[SortDirectionEnum](../enums/_generated_api_.waitforconditions.sortdirectionenum.md)*

*Defined in [src/generated/api.ts:2397](https://github.com/mailslurp/mailslurp-client-ts-js/blob/507ad2d/src/generated/api.ts#L2397)*

Direction to sort matching emails by created time

**`type`** {string}

**`memberof`** WaitForConditions

___

### `Optional` timeout

• **timeout**? : *number*

*Defined in [src/generated/api.ts:2403](https://github.com/mailslurp/mailslurp-client-ts-js/blob/507ad2d/src/generated/api.ts#L2403)*

Max time in milliseconds to retry the `waitFor` operation until conditions are met.

**`type`** {number}

**`memberof`** WaitForConditions

___

### `Optional` unreadOnly

• **unreadOnly**? : *boolean*

*Defined in [src/generated/api.ts:2409](https://github.com/mailslurp/mailslurp-client-ts-js/blob/507ad2d/src/generated/api.ts#L2409)*

Apply conditions only to **unread** emails. All emails begin with `read=false`. An email is marked `read=true` when an `EmailDto` representation of it has been returned to the user at least once. For example you have called `getEmail` or `waitForLatestEmail` etc., or you have viewed the email in the dashboard.

**`type`** {boolean}

**`memberof`** WaitForConditions

repository: PUSHKARMAURYA/mailslurp-client

repo_name: PUSHKARMAURYA/mailslurp-client


text:
# CNN_Visualization
Visualize the features that neural network used to classify objects

Caulate the decline in predicted probability of every region and mask the regions that don't impact prediction.
![image](https://github.com/WuPedin/CNN_Visualization/blob/master/Pembroke.PNG)

Visualize the neurons.
We found that in shallow layer, neurons detected the edge of pembroke.
![image](https://github.com/WuPedin/CNN_Visualization/blob/master/Pembroke_Edge.PNG)

In deeper layers, neurons detected the organs.
Eye of pembroke is as below.
![image](https://github.com/WuPedin/CNN_Visualization/blob/master/Pembroke_Eye.PNG)


text:
# Recognition Oriented Iris Image Quality Assessment in the Feature Space

![network](evaluation/result/network.png)

[Paper](https://arxiv.org/abs/2009.00294)   [Dataset](http://www.cripacsir.cn/dataset/casia-iris-degradation/)

## Prerequisites

- pytorch 1.0
- torchvision 0.2
- opencv 3.4
- scipy
- thop

## Citing

If DFSNet is useful for your research, please consider citing:

```bibtex
@InProceedings{wang-ijcb2020,
  author    = {Leyuan, Wang and Kunbo, Zhang and Min, Ren and Yunlong, Wang and Zhenan, Sun},
  title     = {Recognition Oriented Iris Image Quality Assessment in the Feature Space},
  booktitle = {International Joint Conference on Biometrics 2020 (IJCB2020)},
  year      = {2020}}
}
```

repository: Debatrix/DFSNet

repo_name: Debatrix/DFSNet


text:
# three-screenshake
a screen shake tool for three.js

example here : https://jsfiddle.net/e4h931co/

# how to use it

instantiate it :

```javascript
var screenShake = ScreenShake();
```

update the camera in the loop :
```javascript
function loop() {

  screenShake.update(camera);

  renderer.render(scene, camera);
  requestAnimationFrame(loop);
};
```

if you indend to do something else with the camera, you can check for screenShake.enabled like this :
```javascript
if (screenShake.enabled == true) {
// Then a screenshake is in progress
}
```

in an event listener or any part of your code that must create a screen shake :
```javascript
screenShake.shake( camera, new THREE.Vector3(0.1, 0, 0), 300 /* ms */ );
```
The second argument is the offset at the climax of the screen-shake.
The third argument is the duration of the shake in milliseconds.

# install via npm

`npm i https://github.com/felixmariotto/three-screenshake`

Because this is no ES6 Module, add this Shim to your bundler / `webpack.js`:
```javascript
module.exports = {
  module: {
    rules: [
      {
        test: require.resolve("three-screenshake"),
        use: ['imports-loader?THREE=three', 'exports-loader?ScreenShake']
      }
    ]
  }
}
```
Import and use as described:
```javascript
import * as ScreenShake from "three-screenshake";
...
```

repository: weiserhei/three-screenshake

repo_name: weiserhei/three-screenshake


text:
# SemPryv

## Intro

Pryv.io is a comprehensive solution for managing this particularly sensitive type of data stream, focusing both on data privacy and decentralization.

SemPryv is a system that provides semantization mechanism for enriching Pryv.io personal data streams with standardized specialized vocabularies from third-party providers. It relies on third providers of semantic concepts, and includes rule-based mechanisms for facilitating the semantization process. This implementation is pluggable to the existing Pryv.io platforms.

## References

This repository contains the code of the SemPryv project, developed by the
[AISLab group](https://www.hevs.ch/en/minisites/projects-products/aislab/) with [Pryv](https://pryv.com).

- [AIS Lab group](https://www.hevs.ch/en/minisites/projects-products/aislab/)
- [hes-so valais/wallis](https://www.hevs.ch/)
- [Pryv](https://pryv.com/)

This development is the result of a research project ["Semi-automatic semantic enrichment of personal data streams"](https://hesso.tind.io/record/5222) published online.

# Demo

SemPryv can be tested online at: [https://sempryv.ehealth.hevs.ch/en/auth](https://sempryv.ehealth.hevs.ch/en/auth)

Description & Architecture
==
SemPryv aims to stream data enrichment by providing semantic annotation capabilities on the Pryv.io middleware.
The semantic annotation process associates high-level ontology concepts to the stream events. It can be done in two ways:

1. **Manually** by searching well-known ontology providers (such as bioportal), or
2. **Semi-automated** where annotation suggestions are provided to the users. These suggestions are derived by predefined rules that experts can modify and save them in the system’s knowledge graph.
3. **Fully automated** suggestions: They derived by machine learning models that have been trained on synthetic data from mobile apps combined by users existing annotations.

The architecture of SemPryv is depicted in the picture below. SemPryv has two main components, a web User Interface
for end users and experts and a back end that exposes the core services as a REST API to external applications.
It also connects to a series of providers for semantic vocabularies and also includes endpoints dedicated for the import/export
of HL7 FHIR - compliant data streams, represented as bundle collections of observations. Since the annotations are ready,
streams can be exposed to the Pryv again with all of their metadata.

![](./screenshots/sempryv_architecture.png)
Figure 1: Sempryv Architecture

## User Interface
Every time a user connects with SemPryv she accesses the hierarchical structure of her streams and the corresponding events.
The user must first declare the annotation type in the corresponding field and then she can search for a
semantic annotation into existing ontologies or look for any possible suggestions. A detailed semantization example of
two streams is described below:
* User accesses her streams and events through login process and providing her authorization token. The data consist of two streams:
_Body Temperature_ (BT) and _Heart_ (H). Heart has also a child-stream named _Heart Rate_ (HR). BT and H consist of one
_text/note_ event each, while HR has two events, a note/txt and one with type position/wgs84. Sempryv proposes the already
declared types that inherits from Pryv events (note/txt and position/wgs84) or users can write the type of the annotation by their own as well (figure 2)

* **Search for annotation**: Given the annotation type “note/txt” the user now can add the actual annotation for the specific
type by clicking the ADD button in order to search available by the system ontologies and add a semantic code.
In our example the user searches for an annotation type for “temperature” and a full list of the proposed semantics is provided,
queried from him (figure 3).

User checks and confirms two of the suggestions: **SNOMEDCT | 722490005** and **SNOMEDCT | 56342008**
and so the final annotation is depicted in figure 4. The similar is done for the heart and heart rate stream.

![](./screenshots/search_bar.png)
Figure 2: proposed terms based on stream events

![](./screenshots/query_suggestions.png)
Figure 3: query suggestions

![](./screenshots/streams_annotated.png)
Figure 4: Annotated streams

## Semi-automated suggestions
SemPryv includes the possibility of using predefined rules expressed in its knowledge graph. The rules are defined by
administrators or experts in a json format like this:

```shell
"graph": [{
  "@id": "pryv:bodyTemperature",
  "@type": "skos:Concept",
  "skos:notation": "note/txt",
  "skos:broader": "pryv:temperature",
  "skos:closeMatch": "snomed-ct:386725007"
},
{
  "@id": "pryv:heart",
  "@type": "skos:Concept",
  "skos:notation": "note/txt",
  "skos:closeMatch": "snomed-ct:36407500"
},
{
  "@id": "someRuleSet1",
  "pryv:pathExpression": "body temperature/",
  "pryv:mapping": ["pryv:temperature"]
},
{
  "@id": "someRuleSet2",
  "pryv:pathExpression": "heart/",
  "pryv:mapping": ["pryv:heart"]
}]
```

These rules essentially allow the definition of close terms from different ontologies. We observe that if the kind of annotation type is **note/txt**, the knowledge graph matches Pryv heart streams to a SNOMED-CT code identified as: **snomed-ct:364075005**. Then, the system matches these rules to heart stream path **heart/** and thus provide the final suggestions.

## Fully automated suggestions and finally annotated data
SemPryv also provides automated suggestions to the users based on a machine learning pipeline. When a user wants to annotate
a stream, suggestions are provided by pressing the suggestions button. Two predictive models have been trained and they provide
combined suggestions: 1. A user model which uses the already annotated streams by all users and 2. a synthetic model which has
been trained on data from two mobile applications.

Finally, when one makes an API call to get the streams, he gets the structure of her annotated data where the annotations
have also been saved.

```shell
"annotated_streams": [
  {
    "name": "Body Temperature",
    "created":<PHONE_NUMBER>.839,
    "clientData": {
      "sempryv:codes": {
        "note/txt": [
          {
            "system_name": "SNOMEDCT",
            "code": "722490005",
            "display": "Temperature (property) (qualifier value)",
            "system": "http://snomed.info/sct"
          },
          {
            "system_name": "SNOMEDCT",
            "code": "56342008",
            "display": "Temperature taking (procedure)",
            "system": "http://snomed.info/sct"
          },
          {
            "system_name": "SNOMEDCT",
            "code": "386725007",
            "display": "Body temperature (observable entity)",
            "system": "http://snomed.info/sct"
          }
        ]
       },
      "pryv-browser:bgColor": "#3498db",
      "sempryv:recursive": false
    },
    "modified":<PHONE_NUMBER>.893,
    "children": [

    ],
    "modifiedBy": "cjxa7szlr00471id30j8dtxpd",
    "createdBy": "cjx3edqz8001k1hd33kitvxb8",
    "parentId": null,
    "id": "mass"
  },
  {
    "name": "Heart",
    "created":<PHONE_NUMBER>.827,
    "clientData": {
      "sempryv:codes": {
        "note/txt": [
          {
            "system_name": "SNOMEDCT",
            "code": "467178001",
            "display": "Bedside heart rate monitor (physical object)",
            "system": "http://snomed.info/sct"
          },
          {
            "system_name": "SNOMEDCT",
            "code": "364075005",
            "display": "Heart rate (observable entity)",
            "system": "http://snomed.info/sct"
          }
        ]
      },
      "pryv-browser:bgColor": "#e81034",
      "sempryv:recursive": true
    },
    "modified":<PHONE_NUMBER>.221,
    "children": [
      {
        "name": "Heart Rate",
        "created":<PHONE_NUMBER>.826,
        "clientData": {
          "sempryv:codes": {
            "note/txt": [
              {
                "system_name": "SNOMEDCT",
                "code": "233916004",
                "display": "Heart block (disorder)",
                "system": "http://snomed.info/sct"
              }
            ]
          },
          "sempryv:recursive": false
        },
        "modified":<PHONE_NUMBER>.596,
        "children": [
        ],
        "modifiedBy": "cjxa7szlr00471id30j8dtxpd",
        "createdBy": "cjxa7szlr00471id30j8dtxpd",
        "parentId": "heart",
        "id": "heartRate"
      }
    ],
    "modifiedBy": "cjxa7szlr00471id30j8dtxpd",
    "createdBy": "cjxa7szlr00471id30j8dtxpd",
    "parentId": null,
    "id": "heart"
  }
]
```

# Setup

## Prerequisites

The rest of this documentation is assuming the following prerequisites:

1.  A working and recent linux environment.

2.  A `.env` file in the `backend/` folder containing the following content:

    ```shell
    BIOPORTAL_API_KEY=...
    ```

    The `BIOPORTAL_API_KEY` can be obtained by creating an account on the
    [bioportal website][].

3.  A `.env` file in the `frontend/` folder containing the following content:

    ```shell
    VUE_APP_BACKEND=...
    ```

    The `VUE_APP_BACKEND` should contain the root URL where the backend service
    can be accessed. For instance for development setup it can be set to:
    `http://localhost:8000`.

[bioportal website]: https://bioportal.bioontology.org/account

## Production setup

**Warning:** Building the image the frontend image requires at least 2GB RAM.

To run SemPryv locally in production mode, the following steps are required:

1.  Install `docker` (tested with version `18.05.0-ce`, build `f150324782`)

2.  Ensure the `.env` files exist as described in the
    [requirements](#requirements) section.

3.  Build and deploy the containers with:

    ```shell
    docker-compose up
    ```

If successful, the website should then be accessible at http://localhost.

For a production deployment on a server, the steps are similar, but don't forget
to modify the `docker-compose.yml` file to your need (ports, volumes, …).

## Development setup

For the development setup, two terminals will be needed, one for running the
backend and one for running the frontend. The procedures are described below:

_**Backend**_

1.  Go to the backend directory:

    ```shell
    cd backend
    ```

2.  Create a virtual environment:

    ```shell
    python -m venv venv
    ```

3.  Activate the virtual environment:

    ```shell
    . ./venv/bin/activate
    ```

4.  Install python dependencies for the development:

    ```shell
    pip install -r dev-requirements.txt
    ```

5.  Start the backend development server:

    ```shell
    python -m sempryv
    ```

If successful, you should be able to access a page at http://localhost:8000
returning a `404 Not Found` error.

_**Frontend**_

1.  Go to the frontend directory:

    ```shell
    cd frontend
    ```

2.  Install dependencies with `npm`:

    ```shell
    npm install
    ```

3.  Start the frontend development server:

    ```shell
    npm run serve
    ```

If successful, you should be able to access the website at http://localhost:8080

# Licence

Copyright (c) 2020 Pryv S.A. https://pryv.com & AIS Lab - HES VALAIS/WALLIS https://www.hevs.ch/en/minisites/projects-products/aislab/

This file is part of Open-Pryv.io and released under BSD-Clause-3 License

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.

Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

SPDX-License-Identifier: BSD-3-Clause

repository: pryv/sempryv

repo_name: pryv/sempryv


text:
# brolgar 0.1.2 "Also known as the 'Australian Crane'" (2021-08-06)

## Minor Improvements

* Uses Testthat Third edition, and implements snapshot testing

# brolgar 0.1.1 "Formerly known as the 'native companion'" (2021-05-27)

## Bug fixes

* Address bug with not creating equal strata
* Address warnings when using b_diff_summary, which now returns NA if there is
only one observation, as we can't take the difference of one observation, and
a difference of 0 in these cases would be misleading.

# brolgar 0.1.0 "Antigone rubicunda"

* fix warning bug in `keys_near` related to factors
* Add `feat_diff_summary()` functions to help summarise diff(). Useful for exploring the time gaps in the `index`. (#100)
* sample functions now work with multiple keys (#85, #89) (Thanks to @earowang and @deanmarchiori for their help with this.)
* `facet_sample()` now has a default of 3 per plot
* resolve features(data ,.key, n_obs) error (#71)
* For `near_quantile()`, the `tol` argument now defaults to 0.01.
* provide an S3 generic for `tbl_ts` objects for `keys_near()` - #76
* Add new dataset, `pisa` containing a short summary of the PISA dataset from
 https://github.com/ropenscilabs/learningtower for three (of 99) countries
* add helper functions `index_regular()` and `index_summary()` to help identify
index variables

# brolgar <IP_ADDRESS>00

* remove `feasts` from dependencies as the functions required in `brolgar` are
  actually in `fabletools`.
* add `nearest_lgl` and `nearest_qt_lgl`
* Gave more verbose names to the `wages_ts` data.
* renamed `sample_n_obs()` to `sample_n_keys()` and `sample_frac_keys()`
* renamed `add_k_groups()` to `stratify_keys()`
* removed many of the `l_<summary>` functions in favour of the `features` approach.
* rename `l_summarise_fivenum` to `l_summarise`, and have an option to pass a list of functions.
* rename `l_n_obs()` to `n_key_obs()`
* rename `l_slope()` to `key_slope()`
* added `monotonic` summaries and `feat_monotonic`
* rename `l_summarise()` to `keys_near()`
* make monotonic functions return FALSE if length == 1.
* add `monotonic` function, which returns TRUE if increasing or decreasing, and false otherwise.
* re export `as_tsibble()` and `n_keys()` from `tsibble
* Data `world_heights` gains a continent column
* Implement `facet_strata()` to create a random group of size `n_strata` to put the data into (#32). Add support for `along`, and `fun`.
* Implement `facet_sample()` to create facetted plots with a set number of keys inside each facet. (#32).
* `add_` functions now return a `tsibble()` (#49).
* Fixed bug where `stratify_keys()` didn't assign an equal number of keys per strata (#55)
* Update `wages_ts` dataset to now just be `wages` data, and remove previous `tibble()` version of `wages` (#39).
* Add `top_n` argument to `keys_near` to provide control over the number of observations near a stat that are returned.
* change `world_heights` to `heights`.
* remove function `n_key_obs()` in favour of using `n_obs()` (#62)
* remove function `filter_n_obs()` in favour of cleaner workflow with `add_n_obs()` (#63)

# brolgar <IP_ADDRESS>00

* Made brolgar integrate with `tsibble`.

# brolgar <IP_ADDRESS>90

* Added the `world_heights` dataset, which contains average male height in
  centimetres for many countries. #28
* created `near_` family of functions to find values near to a quantile or percentile. So far there are `near_quantile()`, `near_middle()`, and `near_between()` (#11).
    * `near_quantile()` Specify some quantile and then find those values around
      it (within some specified tolerance).
    * `near_middle()` Specify some middle percentile value and find values
      within given percentiles.
    * `near_between()` Extract percentile values from a given percentile to
      another percentile.
* Create `add_k_groups()` (#20) to randomly split the data into groups to
  explore the data.
* Add `sample_n_obs()` and `sample_frac_obs()` (#19) to select a random group
  of ids.
* Add `filter_n_obs()` to filter the data by the number of observations #15
* Remove unnecessary use of `var`, in `l_n_obs()`, since it only needs
  information on the `id`. Also gets a nice 5x speedup with simpler code
* calculate all longnostics (#4)
* use the word `longnostic` instead of `lognostic` (#9)
* `l_slope` now returns `l_intercept` and `l_slope` instead of `intercept` and
  `slope`.
* `l_slope` now takes bare variable names
* Renamed `l_d1` to `l_diff` and added a lag argument. This makes `l_diff` more
  flexible and the function more clearly describes its purpose.
* Rename `l_length` to `l_n_obs` to more clearly indicate that this counts the
  number of observations.
* Create `longnostic` function to create longnostic functions to package up
 reproduced code inside the `l_` functions.
* Added a `NEWS.md` file to track changes to the package.


text:
# ExtraCredits_GameJam_6

This repository is for my submission to the Extra Credits Game Jam 6, a 72-hour hackathon-like event that saw 523 submissions.

If you want to try out my submission, you can play it here: https://sci-karate.itch.io/combat-mechanic


text:
# Identifier Sentence

### A unique error phrase generator and parser.

The original idea came from a post here: http://blog.asana.com/2011/09/6-sad-squid-snuggle-softly/ and adapted from the
Java code from here: https://github.com/PerWiklander/IdentifierSentence.

I had written this years ago and recently rediscovered it while logging into my [bitbucket](https://bitbucket.org) account.

repository: jtucker/identifiersentence

gha_language: C#

repo_name: jtucker/identifiersentence


text:
[![OS Compatibility][platform-badge]](#prerequisites)
[![Python Compatibility][python-badge]][python-dl]
[![pre-commit][pre-commit-badge]][pre-commit]
[![Code validation](https://github.com/ComplianceAsCode/auditree-arboretum/workflows/format%20%7C%20lint%20%7C%20test/badge.svg)][lint-test]
[![Upload Python Package](https://github.com/ComplianceAsCode/auditree-arboretum/workflows/PyPI%20upload/badge.svg)][pypi-upload]

# auditree-arboretum

The Auditree common fetchers, checks and [harvest][] reports library.

## Introduction

Auditree Arboretum is a Python library of common compliance fetchers, checks & harvest
reports built upon the [Auditree compliance automation framework][auditree-framework].

## Repo content

### Functionality categorization

Arboretum fetchers, checks, and Harvest reports are organized into functional
grouping categories.  The following categories have either been contributed to
or will be contributed to in the near future.  We anticipate that this list will
grow as arboretum matures.

- [Ansible](https://github.com/ComplianceAsCode/auditree-arboretum/tree/main/arboretum/ansible)
- [Auditree](https://github.com/ComplianceAsCode/auditree-arboretum/tree/main/arboretum/auditree)
- [Chef](https://github.com/ComplianceAsCode/auditree-arboretum/tree/main/arboretum/chef)
- [IBM Cloud](https://github.com/ComplianceAsCode/auditree-arboretum/tree/main/arboretum/ibm_cloud)
- [Kubernetes](https://github.com/ComplianceAsCode/auditree-arboretum/tree/main/arboretum/kubernetes)
- [Object Storage](https://github.com/ComplianceAsCode/auditree-arboretum/tree/main/arboretum/object_storage)
- [Pager Duty](https://github.com/ComplianceAsCode/auditree-arboretum/tree/main/arboretum/pager_duty)
- [Splunk](https://github.com/ComplianceAsCode/auditree-arboretum/tree/main/arboretum/splunk)

### Fetchers

Please read the framework documentation for [fetcher design principles][] before
contributing a fetcher.

Fetchers must apply no logic to the data they retrieve. They must write unadulterated
(modulo sorting & de-duplication) into the `/raw` area of the locker via the
framework-provided decorators or context managers.

Fetchers must be atomic - retrieving and creating the data they are responsible
for. Fetcher execution order is not guaranteed and so you must not assume that
evidence already exists and is current in the locker.  Use
[evidence dependency chaining][] if a fetcher depends on evidence gathered by another
fetcher in order to gather its intended evidence.

Fetchers should be as fast as the API call allows. If a call is long running it
should be separated into a dedicated evidence providing tool, which places data
where a fetcher can retrieve it easily & quickly.

### Checks

Please read the framework documentation for [check design principles][] before
contributing a check.

Checks should only use evidence from the evidence locker to perform check operations.
Also, checks **should not** write or change evidence from the evidence locker.  That
is the job of a fetcher.

[Jinja][] is used to produce reports from checks.  As such each check class must have
at least one associated report template in order to produce a check report.  In keeping
with the "DevSecOps" theme, check reports are meant to provide details on violations
identified by checks.  These violations are in the form of failures and warnings.
**They aren't meant to be used to format fetched raw evidence into a readable report.**
[Harvest][harvest] reports should be used to satisfy that need.

### Harvest Reports

Harvest reports are hosted with the fetchers/checks that collect the evidence for
the reports process. Within `auditree-arboretum` this means the harvest report code
lives in `reports` folders throughout this repository. For more details check out
[harvest report development][harvest-rpt-dev] in the [harvest][harvest] README.

## Usage

`arboretum` is available for download from [PyPI](https://pypi.org/project/auditree-arboretum/).

### Prerequisites

- Supported for execution on OSX and LINUX.
- Supported for execution with Python 3.6 and above.

### Integration

Follow these steps to integrate auditree-arboretum fetchers and checks into your project:

* Add this `auditree-arboretum` package as a dependency in your Python project.
* The following steps can be taken to import individual arboretum fetchers and checks.
  * For a fetcher, add a `fetch_<category>_common.py` module, if one does not already
  exist, in your project's `fetchers` path where the `<category>` is
  the respective category folder within this repo of that fetcher.  Having a separate
  common "category" module guards against name collisions across categories.
  * For a check, add a `test_<category>_common.py` module, if one does not already exist,
  in your project's `checks` path where the `<category>` is the respective category folder
  within this repo of that check.  Having a separate common "category" module guards
  against name collisions across providers and technologies.
  * Import the desired fetcher or check class and the `auditree-framework` will handle
  the rest.

  For example to use the Abandoned Evidence fetcher from the `auditree` category, add
  the following to your `fetch_auditree_common.py`:

  ```python
  from arboretum.auditree.fetchers.fetch_abandoned_evidence import AbandonedEvidenceFetcher
  ```

* `auditree-arboretum` fetchers and checks are designed to execute as part of a downstream
Python project, so you may need to setup your project's configuration in order for the
fetchers and checks to execute as desired.  Each category folder in this repository
includes a README.md that documents each fetcher's and check's configuration.
  * In general `auditree-arboretum` fetchers and checks expect an `org` field with content
  that captures each fetcher's and check's configuration settings.

  For example:

  ```json
  {
    "org": {
      "auditree": {
        "abandoned_evidence": {
          "threshold": 1234567,
          "exceptions": {
          "raw/path/to-evidence.json": "This is a good reason",
          "raw/path/to-evidence-2.json": "This is also a good reason"
        }
      }
    }
  }
  ```

* Finally, for a check, be sure to add the appropriate entry into your project's
``controls.json`` file.  Doing this allows you to group checks together as a control
set which is useful for organizing check notifications and targeted check execution.

  For example to use the Abandoned Evidence check, add something similar to the
  following to your project's `controls.json`:

  ```json
  {
    "arboretum.auditree.checks.test_abandoned_evidence.AbandonedEvidenceCheck": {
      "auditree_evidence": {
        "auditree_control": ["arboretum.auditree"]
      }
    }
  }
  ```

[platform-badge]: https://img.shields.io/badge/platform-osx%20|%20linux-orange.svg
[pre-commit-badge]: https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white
[python-badge]: https://img.shields.io/badge/python-v3.6+-blue.svg
[pre-commit]: https://github.com/pre-commit/pre-commit
[python-dl]: https://www.python.org/downloads/
[lint-test]: https://github.com/ComplianceAsCode/auditree-arboretum/actions?query=workflow%3A%22format+%7C+lint+%7C+test%22
[pypi-upload]: https://github.com/ComplianceAsCode/auditree-arboretum/actions?query=workflow%3A%22PyPI+upload%22
[auditree-framework]: https://github.com/ComplianceAsCode/auditree-framework
[harvest]: https://github.com/ComplianceAsCode/auditree-harvest
[fetcher design principles]: https://complianceascode.github.io/auditree-framework/design-principles.html#compliance-fetchers
[evidence dependency chaining]: https://complianceascode.github.io/auditree-framework/design-principles.html#evidence-dependency-chaining
[check design principles]: https://complianceascode.github.io/auditree-framework/design-principles.html#compliance-checks
[Jinja]: https://palletsprojects.com/p/jinja/
[harvest-rpt-dev]: https://github.com/ComplianceAsCode/auditree-harvest#report-development

repository: degenaro/auditree-arboretum

repo_name: degenaro/auditree-arboretum


text:
![MyAlbums](https://raw.githubusercontent.com/mrmauricio/my-albums/master/src/utils/previews/home.png)

# My Albums

## Live Project

The app can be seen in action **[here](https://mrmauricio.github.io/my-albums/)**.

It may occur a certificate error as the AudioDB API seems unstable, but by clicking on cancel everything runs as expected.

## Project Overview

"My Albums" is an app that allows you to search, select and categorize albums you have listened, deciding where it should belong between Masterpiece category (5 stars) and Terrible category (1 star).

## Instructions

### Home Page

On the Home page there are 5 categories:
- Masterpiece (5 Stars)
- Amazing (4 stars)
- Decent (3 stars)
- Bad (2 stars)
- Terrible (1 star)

The albums that are already placed on the categories are my personal choices, feel free to remove them and add yours. To do that, go to the Search page by clicking on the pulsing Add Button on the top right corner of the screen.

### Search Page

On the Search page you can choose an album of your preference and, by clicking on the Add Button on the card's bottom right, you can rate it, deciding in which category it should belong.
You can search by typing on the input or by selecting one of the musical genres. Then, the results will be shown below.

Search page:

![Search page](https://raw.githubusercontent.com/mrmauricio/my-albums/master/src/utils/previews/search.png)

Search example:

![Search example](https://raw.githubusercontent.com/mrmauricio/my-albums/master/src/utils/previews/search-example.png)

Rating an album:

![Rating an album](https://raw.githubusercontent.com/mrmauricio/my-albums/master/src/utils/previews/rate-example.png)

Bands available:

![Bands available](https://raw.githubusercontent.com/mrmauricio/my-albums/master/src/utils/previews/bands-available.png)

## Run Locally

- Clone this repository and go into its src folder.
- Run  `npm install`
- Run  `npm start`
- Go to  `http://localhost:3000`  to view the app.

repository: mrmauricio/my-albums

repo_name: mrmauricio/my-albums


text:
# Change log

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

## Unreleased
* Added `search-live-hub-channel-size` flag to specific the size of the search live hub channel capacity

### Changed
* In general: `eosdb` was renamed to `trxdb`, which shouldn't change much externally.
  * Specifically: the `healthz` endpoint's `eosdb` field is now
    `trxdb`, so you might need to adjust your monitoring.
* [Breaking] `search` flag `--search-common-dfuse-hooks-action-name` changed to `--search-common-dfuse-events-action-name`
* [Breaking] `eosws` transaction lifecycle field `creation_irreversible` changed to `dtrx_creation_irreversible`
* [Breaking] `eosws` transaction lifecycle field `cancelation_irreversible` changed to `dtrx_cancelation_irreversible`
* [Breaking] `abicodec` app default value for `abicodec-cache-base-url` and `abicodec-export-cache-url` flags was changed to `{dfuse-data-dir}/storage/abicache` (fixing a typo in `abicahe`). To remain compatible, simply do a rename manually on disk before starting the update version (`mv dfuse-data/storage/abicahe {dfuse-data-dir}/storage/abicache`).
* [Breaking] `fluxdb` Removed `fluxdb-enable-dev-mode` flag, use `fluxdb-enable-live-pipeline=false` to get the same behavior as before.
* `mindreader` ContinuityChecker is not enabled by default anymore
* `dfuseeos tools check blocks` was renamed to `dfuseeos tools check merged-blocks`

### Removed
* Removed `search-indexer-num-blocks-before-start` flag from `search-indexer`, search-indexer automatically resolved its start block

### Added
* Added `booter` application with its flags.
* Flag: `--node-manager-auto-backup-hostname-match` If non-empty, auto-backups will only trigger if os.Hostname() return this value
* Flag: `--node-manager-auto-snapshot-hostname-match` If non-empty, auto-backups will only trigger if os.Hostname() return this value
* Flags `--mindreader-auto-backup-hostname-match` and `--node-manager-auto-snapshot-hostname-match` (identical to node-manager flags above)
* Flag: `--mindreader-fail-on-non-contiguous-block` (default:false) to enable the ContinuityChecker
* Flag: `--log-level-switcher-listen-addr` (default:1065) to change log level on a running instance (see DEBUG.md)
* Flag: `--common-ratelimiter-plugin` (default: null://) to enable a rate limiter plugin
* Flag: `--pprof-listen-addr` (default: 6060)
* Flag: `--search-common-dfuse-events-unrestricted` to lift all restrictions for search dfuse Events (max field count, max key length, max value length)
* Command `kv` to `tools` with sub command `get`, `scan`, `prefix`, `account`, `blk`, `blkirr`, `trx`, `trxtrace` to retrieve data from trxdb
* Command `db` to `tools` with sub command `blk`, `trx` to retrieve data from trxdb
* Command `check trxdb-blocks` to `tools`, to ensure linearity of irreversible blocks in storage.  This is useful to know if you've missed some block ranges when doing parallel insertions into your `trxdb` storage.
* `trxdb` deduper now reduces storage by removing identical action data and calls the "reduper" to add this data back.

## [v0.1.0-beta3] 2020-05-13

### Added
* Added `--eosq-available-networks` json string to configure the network section of eosq.
``` [
     {
       "id": "id.1",
       "name": "Network Name",
       "is_test": false,
       "logo": "/images/network-logo.png",
       "url": "https://www.example.com/"
     },
   ]
```
* Added `--eosq-default-network` string to configure the default network eosq
* Added `--eosq-disable-analytics` bool to configure eosq analytics
* Added `--eosq-display-price` bool to configure if eosq displays prices
* Added `--eosq-price-ticker` string to configure if eosq price ticker
* Added `--eosq-on-demand` bool to configure if eosq serves an on-demand network
* Added `--eosq-disable-tokenmeta` bool to configure if eosq disables tokenmenta

* [Breaking] To improve dfuse instrumented `nodeos` binary processing speed, we had to make incompatible changes to data exchange format going out of `nodeos`. This requires you to upgrade your dfuse instrumented `nodeos` binary to latest version (https://github.com/dfuse-io/eos/releases/tag/v2.0.5-dm-12.0). Follow instructions in at https://github.com/dfuse-io/dfuse-eosio/blob/develop/DEPENDENCIES.md#dfuse-instrumented-eosio-prebuilt-binaries to install the latest version for your platform.
* [Breaking] `--mindreader-working-dir` default value is now `{dfuse-data-dir}/mindreader/work` instead of `{dfuse-data-dir}/mindreader` this is to prevent mindreader from walking files into the working dir and trying to upload and delete nodes system files like `fork_db.dat`
* Added `--eosq-environment` environment where eosq will run (local, dev, production)
* Added `--apiproxy-autocert-domains`, `--apiproxy-autocert-cache-dir` and `--apiproxy-https-listen-addr` to serve SSL directly from proxy.
* Added `--node-manager-number-of-snapshots-to-keep` and `--mindreader-number-of-snapshots-to-keep` to allow keeping a few (default:5) snapshots only in the store

### Removed
* Removed the `--merger-store-timeout` flag.  Not needed anymore, as some sensible timeouts have been put here and there, using the latest<EMAIL_ADDRESS>that is context-aware.

### Changed

* [Breaking] flag `--node-manager-auto-restore` (bool) replaced with `--node-manager-auto-restore-source` (string)
* [Breaking] flag `--mindreader-auto-restore` (bool) replaced with `--mindreader-auto-restore-source` (string)
* Mindreader now has "producer" plugin enabled to allow taking snapshots
* Mindreader now runs with "NoBlocksLog" option (deleting blocks.log on restart)
* Node-manager and Mindreader now make dfuseeos shutdown when nodeos crashes.
* Node-manager and Mindreader now try to restore from snapshot if they crash within 10 seconds of starting (ex: dirty state)
* fixes dmetrics duplicate registration error (race condition)
* We improve by 4x times the performance of dfuse instrumented `nodeos` binary on heavy EOS Mainnet blocks. This required changes to `nodeos` data exchange format, so you will need to upgrade it, see the `Breaking` change entry at top of this section.
* Fixed behavior of `--eosq-api-endpoint-url` to allow specifying protocol (ex: https://api.mydomain.com)
* The `kvdb-loader` application was renamed `trxdb-loader`. In general what was (confusingly) named `kvdb` is now `trxdb`, so that `kvdb` can now take on its full meaning of a lean key-value storage abstraction (which is also used by FluxDB).
   * All `--kvdb-loader` flags have been renamed to `--trxdb-loader`.
   * Metrics ID for `kvdb-loader` has been changed to `trxdb-loader` (check your dashboards)
* The `--mindreader-merge-and-upload-directly` was renamed to `--mindreader-merge-and-store-directly`.
* `--common-blocks-store-url` now replaces all of these flags:
    * `--mindreader-merged-blocks-store-url`, `--relayer-blocks-store`, `--fluxdb-blocks-store`, `--kvdb-loader-blocks-store`, `--blockmeta-blocks-store`, `--search-indexer-blocks-store`, `--search-live-blocks-store`, `--search-forkresolver-blocks-store`, `--eosws-blocks-store`
* `--common-oneblock-store-url` now replaces these flags:
    *  `--mindreader-oneblock-store-url`, `--merger-one-block-path`
* `--common-backup-store-url` now replaces these flags:
    * `--node-manager-backup-store-url`, `--mindreader-backup-store-url`
* `--search-common-indices-store-url` now replaces these flags:
    * `--search-indexer-indices-store`, `--search-archive-indices-store`
* `--common-blockstream-addr` now replaces these flags:
    * `--fluxdb-block-stream-addr`, `--kvdb-loader-block-stream-addr`, `--blockmeta-block-stream-addr`, `--search-indexer-block-stream-addr`, `--search-live-block-stream-addr`, `--eosws-block-stream-addr`
* `--common-blockmeta-addr` now replaces these flags:
    * `--search-indexer-blockmeta-addr`, `--search-router-blockmeta-addr`, `--search-live-blockmeta-addr`, `--eosws-block-meta-addr`, `--dgraphql-block-meta-addr`
* `--common-network-id` now replaces this flag: `--dgraphql-network-id`
* `--common-auth-plugin` now replaces these flags:
    * `--dgraphql-auth-plugin`, `--eosws-auth-plugin`
* `--fluxdb-statedb-dsn` replaces `--fluxdb-kvdb-store-dsn` (to avoid confusion between what's actually stored in `kvdb` and how FluxDB is using it (as a simple kv store).
* `--trxdb-loader-parallel-file-download-count` replaces `--kvdb-parallel-file-download-count`
* `--common-trxdb-dsn` replaces these flags:
    * `--blockmeta-kvdb-dsn`, `--abicodec-kvdb-dsn`, `--eosws-kvdb-dsn`, `--dgraphql-kvdb-dsn`, `--kvdb-loader-kvdb-dsn`

* Changed default value for storage URL for `fluxdb` and `kvbd` (now named `trxdb`)

### Fixed

* `--kvdb-loader-chain-id` not being taken into account. This affected the decoding of public keys during the `kvdb` loading process.

## [v0.1.0-beta2] 2020-04-27

### Added
* Added `apiproxy` application, with its flags
* Added `--log-format` option for JSON output and `log-to-file` bool (default to true, same behavior as before)
* Filtering (whitelist and blacklist) of what is indexed in Search, based on Google's Common Expression Language.  See [details here](./search/README.md). Added `--search-common-action-filter-on-expr` and `--search-common-action-filter-out-expr`.
    * NOTE: This doesn't affect what is extracted from the chain, allowing you to re-index selectively without a chain replay.

### Changed
* CLI: dfuseeos init now writes dfuse.yaml with the `start` command's flags, also the array of components to start
* CLI: new `{dfuse-data-dir}` replacement string in config flags, also changed default flag values
 * `--node-manager-config-dir` now `./producer` (was `manager/config`)
 * `--node-manager-data-dir` now `{dfuse-data-dir}/node-manager/data` (was `managernode/data`)
 * `--mindreader-config-dir` now `./mindreader` (was `mindreadernode/config`)
 * `--mindreader-data-dir` now `{dfuse-data-dir}/mindreader/data` (was `mindreadernode/data`)
* CLI: regrouped some flags:
 * `--search-indexer-dfuse-hooks-action-name`, `--search-live-dfuse-hooks-action-name`, `--search-forkresolver-dfuse-hooks-action-name` fused into new `--search-common-dfuse-hooks-action-name`.
 * `--search-...-mesh-publish-polling-duration` fused into new `--search-common-mesh-publish-polling-duration`.
 * all of the `--search-mesh-...` options were renamed to `--search-common-mesh-...` (previously `--search-mesh-service-version`, `--search-mesh-namespace`, `--search-mesh-store-addr`)
* `dashboard`: now separate metrics for mindreader vs producer node
* `dashboard` doesn't act as a reverse proxy anymore (`apiproxy` does)
* `dashboard`'s default port is now `:8081`
* `eosq`'s port is now proxied through `:8080`, so use that.
* App `manager` renamed to `node-manager`. All of its flags were changed from `--manager-...` to `--node-manager-...`

### Removed
* The `--search-...-indexing-restrictions-json`.  This was replaced by the filtering listed above.

## [v0.1.0-beta1] 2020-04-17

### Added
* Added `--nodeos-path` to control which `nodeos` executable is used.

### Removed
* Removed `--chain-name`, replaced by `--config-file` (or `-c`)
* Removed `init --reset` option, `dfusebox purge` does it all now.

### Changed
* Renamed `dfusebox` to `dfuse for EOSIO`
  * `dfusebox.yaml` to `dfuse.yaml`
  * `dfusebox-data` to `dfuse-data`
* `--data-dir` now defaults to `./dfusebox-data`, and is separate from a chain name or the config file location.
* `dfusebox init` now only generates a `dfusebox.yaml` config file, which can be booted with `dfusebox start`.
* `dfusebox init` now only has the interactive method. We can later add more programmatic method to boot chains.  With a `dfusebox.yaml` config now, however, we can reuse initializations multiple times.
* License changed to Apache 2.0
* Added GitHub workflow for PR checks

repository: Yup-io/dfuse-eosio

repo_name: Yup-io/dfuse-eosio


text:
# iterm2 module

## Usage

When adding `iterm2` to `config/*/modules`, make sure to put it at the very end so that it ends up add the end of your
shell initialization. It uses the shell prompts etc. so all your other shell setup needs to be done first.

repository: BotTech/dev-setup

repo_name: BotTech/dev-setup


text:
# Capistrano::Bundle::Copy

Package gems and upload them instead of running 'bundle install' on the server.

## Setup

Add the library to your `Gemfile`:

```ruby
group :development do
  gem 'capistrano-bundle-copy', require: false
end
```

And load it in your `Capfile`:

```ruby
require 'capistrano/bundle/copy'
```

## Configuration

You can modify any of the following Capistrano variables in your deploy.rb config.

- `bundle_cache_path` - Set the path where the bundle cache is kept.

## Contributing

1. Fork it
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create new Pull Request

repository: SICSoftwareGmbH/capistrano-bundle-copy

repo_name: SICSoftwareGmbH/capistrano-bundle-copy


text:
---
tags:
- IoT
date: 2012-11-08T00:00:00Z
description: Securing communications between my Arduinos and the outside world using MQTT and Mosquitto. Stop trying to open my garage door people.
title: Securing MQTT communication between Ardruino and Mosquitto
url: /chronicle/2012/11/08/securing-mqtt-communication-between-ardruino-and-mosquitto/
---

_I tried a lot of solutions, experimented heavily, but this was the most consistent way for my monitoring and remote command design. Your mileage may vary (greatly) based on your use case._

As I posted late in the summer, connecting and interacting with an Arduino remotely with MQTT and web sockets is fairly straight forward. Dealing with the security however is not so trivial.

## Captain, we need more power (for the SSL)
While we can make the ATmega328 do many things, doing secure socket layer (SSL) isn't an option. Which leaves us with a bit of a dilemma before we even get started: how do we secure communications?  If we just use the username and password authentication available within both the MQTT libs for Arduino and Mosquitto, we're passing them in the wide open. Anyone with Wireshark and a couple minutes will start opening your garage door.

## Sometimes you need a middle man
In a perfect world, Arduino does SSL (or maybe we're using Rasberry Pi's or Netdruino's) and we don't have any need for a middle man. However, it's not a perfect world, and we have lots of Arduino's we want to securely control from the outside world.  We need a middle man.

In our case, our middle man is a local instance of Mosquitto that we'll run bridged to our outside instance. We're making a few presumptions (in particular that your home network isn't wide open and is secured), but let's for a second pretend you have some device that's always running. In my case, that happens to be a netbook that has been re-purposed as a print server, so it's not seeing constant action.

## Building bridges
Okay, so now our Audrinos are talking and listening the the local instance of Mosquitto. The local network is locked down, so we're not worried about line snooping. Let's start simple, and bridge our local Mosquitto instance with our remote Mosquitto instance.

Bridging Mosquitto instances is fairly well documented (see mosquitto.conf documentation). Sticking with the sane defaults, creating the bridge is like so:

{{< codeblock lang="bash" >}}
#... previous things

address ec2-somethingsomething.us-west-1.compute.amazonaws.com:8883
connection BridgeIt

topic devices/# out "" home
topic cmds/# in remote ""

username SomeUser
password SomePassword

bridge_cafile /etc/keys/myCA.crt
bridge_certfile /etc/keys/myServer.crt
bridge_keyfile /etc/keys/myServer.key

#... other things
{{< /codeblock >}}

Breaking down the config, we're securing the bridge connection for using SSL (to see how to generate the certs and keys, have a look at the mosquitto-tls documentation), we're using a username/password, and we're defining which topics we're sending out and listening for.

## A note on topic mapping: don't loop me
Topic mapping is important, but slightly out of the scope of the security conversation...but I'm going to talk about it anyway. Topic mapping defines which messages will flow across the bridge. It can be very easy to create a loop, where both brokers continuously send the same message back and forth. This is beyond problematic; you will anger the CPU gods and make your broker machines unhappy.

What to do? It really depends on how your overall information design. For me, I remap from the local devices tree into the remote home/devices/+ and to be super paranoid, I add an access control list rule that only allows the bridge user to write to that tree.

## Locking up the remote side
So you've created this bridge, but your remote server needs some options set as well in it's own config to make all this work. For the sake of not being open at all on the remote end, let's not allow anonymous access, require password, and set the defaults to use SSL.

{{< codeblock lang="bash" >}}
#... previous things

acl_file /etc/mosquitto/accesscontrols
allow_anonymous false
password_file /etc/mosquitto/users

bind_address <IP_ADDRESS>
port 8883

cafile /etc/keys/ca.crt
certfile /etc/keys/server.crt
keyfile /etc/keys/server.key

#... other things
{{< /codeblock >}}

To create the password file, you can use mosquitto_passwd.  The access control file will differ based on your information design, but I basically set up some limits on the users that I've defined for my over all system. You could very well not use acl's and the SSL and password file will suffice.

_I'm not going to go indepth on pre-shared keys, but if you're interested in knowing, you could very well use PSK and not use the password\_file at all._

## So where does this leave us?
In the end we end up with two Mosquitto brokers; one in the outside world that only speaks to the web socket server, and one on our inside private network, which only talks to the Arduinos. Together, the two brokers talk over SSL through the bridge.

Since the python Mosquitto library has SSL support, it talks to the outside instance securely. We then run our dashboard and interface panel over HTTPS, which further secures information exchange. And because we're running HTTPS, the web socket service will use WSS (WS over TLS), also secure.

It's a rather long path to secure everything, but in the end, as long as we make sure we don't have any gaps in our local network, we can still talk securely and control those Arduinos remotely.

repository: justinribeiro/blog-pwa

extension: markdown

repo_name: justinribeiro/blog-pwa


text:
# ProductionQueue
### Add production queuing to Civ VI!

![Civ VI Production Queue Screenshot](http://i.imgur.com/ieaQ0iY.jpg)

Installation
============
* Download the mod and extract the contents to the Civilization VI Mods folder.
    * Windows - C:\Users\USERNAME\Documents\My Games\Sid Meier's Civilization VI\Mods
    * OSX - /Users/USERNAME/Library/Application Support/Sid Meier's Civilization VI/Mods
    * Linux - /home/USERNAME/.local/share/aspyr-media/Sid Meier's Civilization VI/Mods
* Enable the mod in the Additional Content section of the main menu.

Controls
========
Actions when clicking an item in the "Choose Production" panel:
* Left-Click: Add the item to the bottom of the queue.
* Control+Left-Click or Middle-Click: Add the item to the top of the queue.

Actions when click an item in the "Production Queue" panel:
* Left-Click and drag to new position: Move the item to the position when the mouse button is released. i.e. Drag and drop.
* Double Left-Click or Middle-Click: Move the item to the top of the queue.
* Left-Click and drag off queue: Remove the item from the queue.
* Hover: Reveal reserved plot of placed item (district or wonder) on the map.

Instructions
============
When you first load a new game with the mod enabled, the production queue panel will be visible by default to the left of a city's production menu. The panel can be collapsed by clicking the small tab on the upper-left. Using the controls listed in the section below, you can add/remove and manipulate production items in a per-city queue.

All types of production items are eligible to be added to the queue. This includes districts and wonders! When adding a district or wonder to the queue, you will choose a plot for it like normal. However, the actual placing of the plot will not occur until the item is in the top position of the queue. At that time, it will automatically place the item on the plot that was selected upon adding it to the queue. Anytime before it reaches the top of the queue, you are free to remove it from the queue and re-place it. But remember, as soon as it reaches the top of the queue, it will be placed and be permanent (as occurs when placing a district or wonder in the base game).

Districts and buildings that are prerequisites for other production items that are already researched (techs and civics) will unlock the next one. For example, you can queue a Commercial Hub and then immediately queue a Market if the required techs are researched. Continuing with this same example, the Market added below the Commercial Hub would be incapable of being moved ahead of it. In other words, the required order of the queue will be maintained. If you attempt to reorder an item in a way that would be impossible, it will move as far as it can before stopping. If you attempt to remove an item which is depended upon by other items below it, the removal will cascade and remove all items within the same dependency chain. In our previous example, this would mean that removing the Commercial Hub would also result in the Market being removed.

Units in a city's queue which become obsolete will be automatically switched to the unit that is replacing it. In the event the unit that replaces the now obsolete unit is ineligible for production, the units will be removed from your queue. For example: Your queued Warriors are forced to become obsolete upon learning the Gunpowder tech, but the unit which replaces them is the Swordsman which requires Iron. If you do not have Iron, the Warriors will be removed from the queue rather than being upgraded to Swordsmen.

Altered Game Assets
-------------------
In case you are curious up front which game assets have been modified, here is a list:
* UI\Panels\ProductionPanel.lua
* UI\ProductionPanel.xml
* UI\StrategicView_MapPlacement.lua
* UI\SupportFunctions.lua

Copyright 2019 Kevin Blease. This item is not authorized for posting on Steam, except under the Steam account named<EMAIL_ADDRESS>

repository: kblease/ProductionQueue

gha_language: Lua

repo_name: kblease/ProductionQueue


text:
# stm32f746_disco_no_os
LittlevGL ported to STM32F746G-DISCO

# How to get started
1. Visit https://atollic.com/resources/download/ to download and install the Atollic IDE.
2. Clone (or download) this GitHub repository to a folder on your computer and update the submodules:

```sh
git clone --recursive https://github.com/littlevgl/stm32f746_disco_no_os_atollic.git
```

3. Import the project into your workspace.
4. Build and run!


text:
# ES6 Weather Forecast
ES6 Weather Forecast in JavaScript using EcmaScript 6 (2015).
Looks like this:
![ES6 Weather Forecast](./screenshots/es6WeatherForecast.png)

Demo [here](http://josequinto.com/forecast/index.html)

## Features
- [ES6](http://es6-features.org) (with [babel](https://babeljs.io))
- [SCSS](http://sass-lang.com)
- Hot Module Replacement for faster development
- Axios as promise based HTTP Client. Read this [Fetch vs Axios comparison](https://github.com/mzabriskie/axios/issues/314)
- [Forecast API](http://openweathermap.org/forecast5)
- Responsive design
- Mock Data allowing working offline and saving calls to weather API
- Webpack
    - [Webpack-dev-server](https://webpack.js.org/how-to/develop/#webpack-dev-server)
    - Webpack development environment configuration
    - Webpack Babel loader configuration
    - Webpack SCSS configuration
    - [Webpack configuration for HMR](https://webpack.js.org/how-to/hot-module-reload)
    - Webpack production configuration
         - Split out css files (two threads, JS and CSS) using [ExtractTextPlugin](https://github.com/webpack/extract-text-webpack-plugin)
         - [UglifyJsPlugin with options](https://github.com/webpack/webpack/blob/v1.13.3/lib/optimize/UglifyJsPlugin.js)
         - Use include in the loader instead of the exclude. [More info](http://stackoverflow.com/questions/37823764/how-include-and-exclude-works-in-webpack-loader)
         - More perfomance tips<EMAIL_ADDRESS>- Jest as testing tool. Tests under \_\_tests\_\_ folder
    - Add test like [this](https://github.com/andrew-codes/react-jest-browserify-gulp-bootstrap/blob/master/__tests__/components/CheckboxWithLabel-spec.js)

### Features NOT INCLUDED (with more time...)
- Create React component as well
- Add a selector of Locations to allow the user to select more Locations (not only London)
- Improve the design
- Add more information about clouds, wind, etc...
- Even if that is responsive (i used float divs) it could be targeted with media queries and the mobile user experience could be improved.
- Initial Spinner meanwhile the app is doing the query to weather API
- Add the results to sessionStorage cache

## Getting Started
### Install pre-requisites
- Node.js and NPM: [Download and install](https://nodejs.org/). *I have version 6.6.0 of Node and 3.10.6 of NPM on Windows PC*
- Git: [Download and install](https://git-scm.com/). *I have version 2.7.4 installed on Windows PC*

### Clone Repo
1.
    - Go to https://github.com/username/es6-weather-forecast
2. Click on **"Clone or download"** and Copy to clipboard the url ending on .git.
3. Open your command line and go to your directoy
*You don't need to create a specific folder for the project, it will be created by git*
4. Clone the repo on your machine:
```
$ git clone https://github.com/username/es6-weather-forecast
```
*Note: That will create a new folder called es6-weather-forecast with all the files in.*

### Install Project dependencies
We will use npm i to install all our dependencies in our node_modules folder.

```
$ cd es6-weather-forecast
$ npm i
```

### Run the app in Development mode
```
$ npm run start
```

### Build
```
$ npm run build
```

### Lint
```
$ npm run lint
```

### Test
```
$ npm run test
```

## Contributing
Please feel free to add your own improvement. I am waiting your Pull Request (PR).

## License
MIT License
Copyright (c) 2016 Jose Quinto Zamora


text:
## DDD CQRS ES Boilerplate for Symfony

A Boilerplate that uses Domain Driven Design, Command Query Responsibility Segregation and
Event Sourcing for symfony.

## How to install

```bash
composer create-project cydrickn/symfony-ddd-cqrs-es
```

## Run using docker

```bash
cd opt/
docker-compose up -d
```

Run migration when all container are ready

```bash
docker-compose exec php php bin/console doctrine:migrations:migrate
```

Now you can access the site using http://localhost:8080/

You can access the api doc using http://localhost:8080/api/doc


text:
# Containerized Ethereum Network
Automated containerized Ethereum (geth) Network using shell scripting, with sample python script to execute a smart contract.

### Note that Blockchain & crypto currency are nascent technologies and can change at anytime.
### So this setup might stop working in future.
### There are many great guides and articles out there. This is a implementation which can be easily understood by any programer

This setup was tested on Windows & Ubuntu.

## Prerequisite

1. docker or docker-toolbox (windows) should be installed.
2. Install python 3.6
3. Install build tools for visual studio 2017 from one of the [link](https://www.visualstudio.com/downloads/#build-tools-for-visual-studio-2017).
It is 4+ gb download and takes 20-30min installation time.

   [click here to know the reason](https://wiki.python.org/moin/WindowsCompilers#Microsoft_Visual_C.2B-.2B-_14.0_standalone:_Build_Tools_for_Visual_Studio_2017_.28x86.2C_x64.2C_ARM.2C_ARM64.29)
4. Install [git](https://git-scm.com/download/win)
5. On Windows install [git bash](https://git-scm.com/download/win) or cygwin. Linux users can skip this step.
6. Clone my repository : ```git clone https://github.com/Mastro-Geppetto/containerizedEthereumNetwork.git```
7. Update python setuptools : ```pip install --upgrade setuptools```
8. Change directory to the cloned git repo directory.
9. Install python libs to interact with Ethereum Network : ```pip install -r requirements.txt```
10. Check docker is running : ```docker images```

## Build geth docker image
1. ```geth``` is Ethereum client written in Go.
2. We have a number of docker image options from custom docker image to official image.
3. Build Custom image with name *local/ethereumbase:latest*: ```docker build -t "local/ethereumbase:latest" -f ./Dockerfile .```
4. Instead to use official ```Dockerfile-official-alltools-image``` build with ```docker build -t "ocal/ethereumbase:latest" -f ./Dockerfile-official-alltools-image .```
5. Check Docker image ```docker images```

## Start network
- In bash shell change directory to cloned directory.
- ```./deploy```
- It will start
  - geth nodes : one bootnode, two miners and one eth node to interact : check Container IDs with ```docker ps```
  - create a bridge network "ether_priv_net" between containers : check IP with ```docker network ls```
  - disk volumes per nodes named as "bootnode_vol", "miner_1_vol" and so on : check with ```docker volume ls```
  - **Note: genesis.json is present in [common folder](https://github.com/Mastro-Geppetto/containerizedEthereumNetwork/tree/master/common)**
- This network has 9 prefilled accounts. Check [keystore](https://github.com/Mastro-Geppetto/containerizedEthereumNetwork/tree/master/common/keystore).
  - Out of that first four are used by bootnode, 2 miners & 1 eth node.
  - [Google Genesis ethereum](https://www.google.com/search?q=genesis+block+ethereum)
  - [What is Mining in ethereum ?](https://github.com/ethereum/wiki/wiki/Mining#introduction)

## Interact with network using command line in nodes
- **Miner node**
  - Initial DAG creation will take 5/10 mins. Miner nodes will create initial [DAG]( https://ethereum.stackexchange.com/questions/1993/what-actually-is-a-dag)
  - check miner logs. On bash run ```docker log miner_1```
  - **SAMPLE LOG**
  ```
  Generating DAG in progress               epoch=0 percentage=99 elapsed=19m41.071s
  Generating ethash verification cache     epoch=1 percentage=3  elapsed=3.284s
  ```
- **Eth client node**
  - Mean while check accounts and balance on eth node
  - attach to eth node's *geth* console : ```docker exec -it eth geth attach```
  - use geth console to check that block count is increasing each 10 sec as configured in [genesis](https://github.com/Mastro-Geppetto/containerizedEthereumNetwork/tree/master/common)
  - use the below commands one by one.
  ```
  eth.blockNumber
  # might output 16
  eth.hashrate
  # 10
  eth.accounts
  #["0xa4b5db581bdee808c1896fac99ff22074885b079", "0x085db52a09584a953fab3046db4dd19474affc33", "0xe8c330a9112191ddcd65dd10f7ec60f32ab2067e", "0xf8ae31b2f7e68c36fff1370326aa6a7a9c586d69", "0x7eb19dbc863aa4f2e601b0e736a6000acc0e14b2", "0xc513ce206b0cd02b12b85796f87f6505cbf0e6f5"]
  eth.getBalance(eth.accounts[0])
  ```
  - In this non bootnode check that it shows 2 peers ```admin.peers```
  - Check your own address ```admin.nodeInfo.enode```
  - Check below for more examples.

## Stop network
- In bash shell from cloned directory give ```./shutdown```
- **Note** we created docker disk volumes, ```./shutdown``` will not clear these.
- Thus giving ```./deploy``` to a ```./shutdown``` network will start iit from last mined block.

## Cleanup network
- In bash shell from cloned directory give ```./shutdown``` then ```./cleanup```

## Console Example of Transcation : sending ether (crypto currency) to another address
- Login to client node ```docker exec -it eth geth attach```
- ```eth.coinbase``` will produce your coinbase / purse hash. Example ```"0xa4b5db581bdee808c1896fac99ff22074885b079"```
- ```eth.accounts``` will show list of all accounts on this network.
  - These are visible here because they were add in [genesis block](https://github.com/Mastro-Geppetto/containerizedEthereumNetwork/tree/master/common)
  - ```Output : ["0xa4b5db581bdee808c1896fac99ff22074885b079", "0x085db52a09584a953fab3046db4dd19474affc33", "0xe8c330a9112191ddcd65dd10f7ec60f32ab2067e", "0xf8ae31b2f7e68c36fff1370326aa6a7a9c586d69", "0x7eb19dbc863aa4f2e601b0e736a6000acc0e14b2", "0xc513ce206b0cd02b12b85796f87f6505cbf0e6f5"]```
- Send some ether to another account. It will output **transaction hash**.
```eth.sendTransaction({'from':eth.coinbase, 'to':'0xae17b64a594024b4df2158f804795cfba0d356f2', 'value':web3.toWei(3, 'ether')})
Output : "0xf2b0f7ef1ee3dd6c9ae5857ca481354efa46277a241e3d5369c070a6a577358e"
```
- using the **Output** hash get transaction receipt.
  - **Note** Transaction processing time == mining rate of block
  - **for a unprocessed transaction**
  ```
  eth.getTransactionReceipt("0xf2b0f7ef1ee3dd6c9ae5857ca481354efa46277a241e3d5369c070a6a577358e")

  Error: unknown transaction
      at web3.js:3143:20
      at web3.js:6347:15
      at web3.js:5081:36
      at <anonymous>:1:1
  ```
  - **processed transaction**
  ```
  eth.getTransactionReceipt("0xf2b0f7ef1ee3dd6c9ae5857ca481354efa46277a241e3d5369c070a6a577358e")
  {
    blockHash: "0xd58bfda2fb8800c0c7ad3ce32c2523b3526e5602f9a8c506f6df785955f0a41b",
    blockNumber: 24,
    contractAddress: null,
    cumulativeGasUsed: 21000,
    from: "0xa4b5db581bdee808c1896fac99ff22074885b079",
    gasUsed: 21000,
    logs: [],
    logsBloom: "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
    status: "0x1",
    to: "0xae17b64a594024b4df2158f804795cfba0d356f2",
    transactionHash: "0xf2b0f7ef1ee3dd6c9ae5857ca481354efa46277a241e3d5369c070a6a577358e",
    transactionIndex: 0
  }
  ```

## Smart Contract
- Ethereum uses ["Solidity"](https://solidity.readthedocs.io/en/v0.5.1/) programing language & online Compiler named ["remix"](http://remix.ethereum.org/).
- Code is quite comprehensible.
- I have pre-compiled my smart contract code online & put in the python script.
- [This is another smart contract example.](http://remix.ethereum.org/#optimize=false&version=soljson-v0.4.20+commit.3155dd80.js)
- My solidity code with comments
  ```
  pragma solidity ^0.4.0;
  contract auid{
      /* Define variable value of the type string */
      string value;
      /* Define variable owner of the type address */
      address owner;

      /* CTOR : This runs when the contract is executed */
      /* This function is executed at initialization and sets the owner of the contract */
      function auid() public { owner = msg.sender; }

      /* DTOR : Function to recover the funds on the contract */
      function kill() public { if (msg.sender == owner) selfdestruct(owner); }

      /* Main function */
      function setvalue(string _value) public {
          value = _value;
      }

      /* Constant function => no charges to user to execute */
      function getvalue() public constant returns (string) {
          return value;
      }

      ////////////////////////////////////////////////
      // BELOW EXPERIMENTAL CODE SHOULD BE SKIPPED
      // we can log events
      // event setvalue
      /*
      // array of viewers : To Be Done
      address [] viewers;

      function transferOwnership( address newOwner ) public {
        owner = newOwner;
      }*/
  }
  ```

## Python [client](https://github.com/Mastro-Geppetto/containerizedEthereumNetwork/tree/master/main.py) code
- From cloned directory start python script interactively ```python -i main.py```
- My python code ```JSONRPCBaseClient``` directly pushes compiled *bytecode* to deploy a smart contract.
  - ```JSONRPCBaseClient``` will connect to eth node on ```<IP_ADDRESS>:8545```
- In python console after first step select a password ``` password="UR_OWN_Password"
- *Create user* ```userId = createuser( password ) ```
- *Deploy contract* ```fixed_contract_hash = a=deploy_contract( userId, password )```
  - This operation will consume some gas ( actually smaller denomination of ether called wei ) because blockchain was modified.
    - "gas" is a proportion or a priority set by user. In this code I have defaulted the gas value to 1.
- *Set LandRecord* ```trans_receipt = setdata( userId, password, fixed_contract_hash )```
  - Each modify ie set operation will also consume gas.
  - In my actual project we saved a hash string which translated to a secured file server URL.
  - This URL was meaningless outside our server.
- *Get LandRecord* ```getdata( fixed_contract_hash )```
  - This doesn't modify blockchain so its free of any wei charge.


text:
Historigal

Learn about history with a google themed interface.

  Key Features •
  How To Use •
  License

## Key Features

* Google Themed Interface - A similar feel to the popular website (https://www.google.com)
  - Search functionality is virtually the same
* 37860 Historical Entries in Database
  - Events covered from 300 B.C. to the year 2012

## How To Use

To clone and run this application, you'll need [Git](https://git-scm.com) and [Node.js](https://nodejs.org/en/download/) (which comes with [npm](http://npmjs.com)) installed on your computer. From your command line:

```bash
# Clone this repository
$ git clone https://github.com/davidagustin/Historigal.git

# Go into the repository
$ cd Historigal

# Install dependencies
$ npm install

# Run the app
$ npm start
```

Note: If you're using Linux Bash for Windows, [see this guide](https://www.howtogeek.com/261575/how-to-run-graphical-linux-desktop-applications-from-windows-10s-bash-shell/) or use `node` from the command prompt.

## License
MIT

repository: davidagustin/Historigal

repo_name: davidagustin/Historigal


text:
#
# This repo was created with: https://github.com/ReDoc-ly/create-openapi-repo
#

Inside that directory, you can run several commands:

  npm start
    Starts the development server.

  npm run build
    Bundles the spec and prepares web_deploy folder with static assets.

  npm test
    Validates the spec.

  npm run gh-pages
    Deploys docs to GitHub Pages. You don't need to run it manually if you have Travis CI configured.

We suggest that you begin by typing:

  cd puppetdb-openapi
  npm start

repository: EncoreTechnologies/puppetdb-openapi

gha_language: Makefile

repo_name: EncoreTechnologies/puppetdb-openapi