text:
# woop
The Woopest Woop

# **Resources**

1. [https://scrimba.com/](https://scrimba.com/) - Scrimba is a powerful new way of learning code. Play around with the instructors code any time, right in the player.
2. [https://postmake.io/](https://postmake.io/) - A directory of the best tools and resources for your projects
3. [https://www.cnet.com/how-to/21-chrome-shortcuts-you-need-to-know/](https://www.cnet.com/how-to/21-chrome-shortcuts-you-need-to-know/)
4. [https://workona.com/](https://workona.com/) - worth checking plugin for chrome tab management
5. [https://jsbin.com/?html,output](https://jsbin.com/?html,output) - a playground for html, css & js if you just want to experiment
6. [https://www.learnenough.com/command-line-tutorials/basics](https://www.learnenough.com/command-line-tutorials/basics) - bad boy hacks for mastering the terminal
7. [https://www.theodinproject.com/](https://www.theodinproject.com/) open source/free  alternative to codecademy (.js is worth checking out)
8. [https://javascript.works-hub.com/learn/](https://javascript.works-hub.com/learn/) - a bit more advanced, but how to build various things in .js, node, react
9. [https://resilientwebdesign.com/](https://resilientwebdesign.com/)
10. [https://developer.mozilla.org/en-US/docs/Web/CSS/color_value](https://developer.mozilla.org/en-US/docs/Web/CSS/color_value) - Hex color list
11. [https://alistapart.com/article/responsive-web-design](https://alistapart.com/article/responsive-web-design) - How responsive web started
12. [https://news.ycombinator.com/hn.js](https://news.ycombinator.com/hn.js) - Javascript file from HackerNews
13. [https://caniuse.com](https://caniuse.com/) - Testing cross browser support for various properties
14. [https://www.arun.is/blog/10-year-challenge/](https://www.arun.is/blog/10-year-challenge/) - 10 years
15. [https://github.com/charlax/professional-programming](https://github.com/charlax/professional-programming) - A collection of full-stack resources for programmers.
16. [https://google-webfonts-helper.herokuapp.com/fonts](https://google-webfonts-helper.herokuapp.com/fonts) - Fonts helper tool
17. [https://medium.com/level-up-web/the-ultimate-guide-to-css-103b0f883de3](https://medium.com/level-up-web/the-ultimate-guide-to-css-103b0f883de3) - CSS cheatsheets
18. [https://usefyi.com/templates/](https://usefyi.com/templates/) - Use FYI templates
19. [https://daneden.github.io/animate.css/](https://daneden.github.io/animate.css/) - Simple animations with CSS
20. [
https://www.udemy.com/advanced-css-and-sass/?couponCode=LAUNCHSITE4](https://www.udemy.com/advanced-css-and-sass/?couponCode=LAUNCHSITE4) Jonas' advanced CSS class with coupon
21. [https://bennettfeely.com/clippy/](https://bennettfeely.com/clippy/) - Easy clip-path (HTML5) tool to clip images in browser.
22. [https://discoverthreejs.com/](https://discoverthreejs.com/) - upcoming threejs book. Free first chapter.
23. [https://www.cncf.io/the-childrens-illustrated-guide-to-kubernetes/](https://www.cncf.io/the-childrens-illustrated-guide-to-kubernetes/) kubernetes explained
24. https://www.nngroup.com/articles/breadcrumbs/ Breadcrumbs - UIUX design guidelines.

# On editors]

1. [https://app.programmingfonts.org/](https://app.programmingfonts.org/) - test yer fonts

# VSCode

1. [https://vscodecandothat.com/](https://vscodecandothat.com/) - VS Code tips and tricks
2. [https://vscodecandothat.com/](https://vscodecandothat.com/) - What VS Code can do... even makes coffee!🙊

# On Javascript

1. [https://github.com/bpesquet/thejsway](https://github.com/bpesquet/thejsway)
2. [https://scrimba.com/search?q=javascript](https://scrimba.com/search?q=javascript) (Videos and tutorials)
3. [https://scrimba.com/c/cast-24](https://scrimba.com/c/cast-24) @Tom Belton a nice way to "buidl" and apply what you're learning by creating a very simple submission form. @Jacob Papageorgiou schweeeet thnx m8!
4. [https://codepen.io/JohnPaulFich/pen/MXmzzM](https://codepen.io/JohnPaulFich/pen/MXmzzM) A simple "To-do" list in .js to explore functions.
5. [https://reacthandbook.com/](https://reacthandbook.com/) Flavio Copes. For when we make better haxz0rz
6. https://learnjavascript.online/
7. https://dustinpfister.github.io/2017/12/04/lodash_once/  closures
8. [https://javascript.info](https://javascript.info) detailed JS text tutorials
9. https://medium.freecodecamp.org/state-in-javascript-explained-by-cooking-a-simple-meal-2baf10a787ee JS State explained 👨🏻🍳
10. https://medium.com/@bretcameron/12-javascript-tricks-you-wont-find-in-most-tutorials-a9c9331f169d

# APIs
1. [https://public-apis.xyz/](https://public-apis.xyz/) - here lie the public APIs

# Email newsletter worth subscribing to

1. [https://hackernewsletter.com/](https://hackernewsletter.com/) - Weekly picks from [https://news.ycombinator.com/](https://news.ycombinator.com/)
2. [https://github.com/zudochkin/awesome-newsletters/blob/master/README.md](https://github.com/zudochkin/awesome-newsletters/blob/master/README.md) many more newsletters but not sure what would be best. 🤔
3. [https://www.webdesignernews.com/](https://www.webdesignernews.com/) - I enjoy this as it has a variety of links on a daily basis - however these are still FOMO inducing emails
4. [https://labnotes.org/](https://labnotes.org/) - Definitely worth subscribing to - a weekly email about code, design, technology, and people
5. [https://frontendfoc.us/](https://frontendfoc.us/) - Front End Focus. All things front end, with latest updates.

# Git

1. https://medium.com/@i_AnkurBiswas/common-git-mistakes-and-how-to-fix-them-10184cd5fa77

# Music

1. [https://musicforprogramming.net/](https://musicforprogramming.net/)

# Time Wasters, Resource finders

1. [https://www.producthunt.com/golden-kitty-awards-2018](https://www.producthunt.com/golden-kitty-awards-2018) - Some great products in here
2. [https://hackernewsletter.com/2018/](https://hackernewsletter.com/2018/) - Some good linkage here - also subscribe to
3. [https://github.com/mostmojo/Cookbook](https://github.com/mostmojo/Cookbook) - "Recipe Cookbook" - could waste lots of time debugging but it works 🤭

# Noob How To's...

1. [https://stackoverflow.com/questions/21012203/how-can-i-install-macvim-on-os-x](https://stackoverflow.com/questions/21012203/how-can-i-install-macvim-on-os-x)
2. [https://stackoverflow.com/questions/2933192/what-is-parsing-in-terms-that-a-new-programmer-would-understand/2933218#2933218](https://stackoverflow.com/questions/2933192/what-is-parsing-in-terms-that-a-new-programmer-would-understand/2933218#2933218) (If I gave you an english sentence, and asked you to break down the sentence into its parts of speech (nouns, verbs, etc.), you would be parsing the sentence).
3. [https://www.sitepoint.com/nokogiri-fundamentals-extract-html-web/](https://www.sitepoint.com/nokogiri-fundamentals-extract-html-web/) (extract an html page to terminal for initial scraping)
4. [https://www.youtube.com/watch?v=-9ZheXYOMeM&t=2s](https://www.youtube.com/watch?v=-9ZheXYOMeM&t=2s) Build a landing page in 2hrs
5. https://help.github.com/articles/fork-a-repo/ How to commit from local machine to github
6. https://flexboxfroggy.com Children's frog game to learn grid

repository: michailb/woop

repo_name: michailb/woop


text:
# dic
translate Japanese 2 English using EDICT written in only Go standard Library.

## Usage
```bash
Usage of dic:
  -c	Match specification: CONTAIN   (ANYWHERE)
  -e	Match specification: ENDWITH   (HEADWORD)
  -p int
    	Max result count(default: 3)
  -s	Match specification: STARTWITH (HEADWORD)
  -version
    	Print version information and quit.
  -w string
    	Word translated by
```

Hit On Start With Headword
![startwith headword image](images/startwith_headword.png)

Hit On End with Headword
![endwith headword image](images/endwith_headword.png)

Hit On Contain Anywhere
![contain anywhere image](images/contain_anywhere.png)

## Installation

```bash
$ git clone https://github.com/ShingoYadomoto/dic.git
$ cd dic
$ go build
$ ./dic -w 経済
```

repository: ShingoYadomoto/dic

branch_name: refs/heads/main

extension: md

license_type: permissive

repo_name: ShingoYadomoto/dic


text:
---
slug: welcome
title: Welcome
author: Taimoor Khan
author_title: Core Engineering @ ReactPakistan
author_url: https://github.com/Taimoormk
author_image_url: https://avatars0.githubusercontent.com/u/27800340?s=150&v=4
tags: [react, pakistan, welcome, documentation]
---

### We Welcome you at React Pakistan Docs
Thank you for making this far to be `here`. It means a lot for us, hope you will
enjoy using `React Pakistan` packages and also will get all the relevant docs that you
need for your successful project development.

### The Bigger Picture
Our projects are distributed into three major categories:
  - ReactJS
  - React Native
  - Utils

### Tech Stack
Our preferred technologies used for these projects are as follows:
  - ReactJS
  - React Native
  - TypeScript
  - StyledComponents
  - Storybook
  - Jest
  - ESlint
  - CSS Grid
  - GitHub CI

### List of all Published Projects
  - React Commons Collection
  - React UI Collection
  - React Icon Collection
  - React Logo Collection
  - React Emoji Collection
  - React Native Commons Collection
  - React Native UI Collection
  - React Native Icon Collection
  - React Native Logo Collection
  - React Native Emoji Collection
  - React Native Boilerplate
  - Util Functions
  - Util React Native Functions
  - Eslint Shared Config
  - React Pakistan Docs

license: MIT

repository: react-pakistan/react-pakistan-docs

branch_name: refs/heads/dev

gha_language: JavaScript

gha_license_id: MIT

repo_name: react-pakistan/react-pakistan-docs


text:
To search in a specific data bag for a specific data bag item, enter the
following:

``` bash
knife search admins 'id:charlie'
```

where `admins` is the name of the data bag and `charlie` is the name of
the data bag item. Something similar to the following will be returned:

``` bash
1 items found
_rev:       1-39ff4099f2510f477b4c26bef81f75b9
chef_type:  data_bag_item
comment:    Charlie the Unicorn
data_bag:   admins
gid:        ops
id:         charlie
shell:      /bin/zsh
uid:        1005
```

branch_name: refs/heads/master


text:
# `per1234/install-arduino-ci-script-action`

A [GitHub Actions](https://github.com/features/actions) action for installing [per1234/arduino-ci-script](https://github.com/per1234/arduino-ci-script).

Although written for use with Travis CI. At least some of the functions of the per1234/arduino-ci-script script are usable with GitHub Actions.

Please see [action.yml](./action.yml) for the documentation of the action's inputs.

## Example usage

```yaml
- uses: per1234/install-arduino-ci-script-action@v1
  with:
    installation-path: extras/ci/tools/arduino-ci-script
```

#### Contributing
Pull requests or issue reports are welcome! Please see the [contribution rules](.github/CONTRIBUTING.md) for instructions.


text:
# libcarina

[![GoDoc](https://godoc.org/github.com/rackerlabs/libcarina?status.png)](https://godoc.org/github.com/rackerlabs/libcarina)

Provisional Go bindings for the beta release of [Carina](https://getcarina.com) by Rackspace. If you're looking for a client binding, [`carina`](https://github.com/rackerlabs/carina) is your friend.

![](https://cloud.githubusercontent.com/assets/836375/10503963/e5bcca8c-72c0-11e5-8e14-2c1697297d7e.png)

## Examples

Getting straight to Docker with only your username and API Key:

```go
package main

import (
	"fmt"
	"os"
	"time"

	"github.com/getcarina/libcarina"
	"github.com/samalba/dockerclient"
)

func main() {
	var err error

	username := os.Args[1]
	apiKey := os.Args[2]
	clusterName := os.Args[3]

	// Connect to Carina
	cli, _ := libcarina.NewClusterClient(libcarina.BetaEndpoint, username, apiKey)

	// Create a new cluster
	cluster, _ := cli.Create(libcarina.Cluster{ClusterName: clusterName})

	// Wait for it to come up...
	for cluster.Status == "new" || cluster.Status == "building" {
		time.Sleep(10 * time.Second)
		cluster, err = cli.Get(clusterName)
		if err != nil {
			break
		}
	}

	// Get the IP of the host and a *tls.Config
	host, tlsConfig, _ := cli.GetDockerConfig(clusterName)

	// Straight to Docker, do what you need
	docker, _ := dockerclient.NewDockerClient(host, tlsConfig)
	info, _ := docker.Info()
	fmt.Println(info)

}
```

repository: linearregression/libcarina

repo_name: linearregression/libcarina


text:
---
layout: "sakuracloud"
page_title: "SakuraCloud: sakuracloud_packet_filter"
subcategory: "Networking"
description: |-
  Get information about an existing Packet Filter.
---

# Data Source: sakuracloud_packet_filter

Get information about an existing Packet Filter.

## Example Usage

```hcl
data "sakuracloud_packet_filter" "foobar" {
  filter {
    names = ["foobar"]
  }
}
```
## Argument Reference

* `filter` - (Optional) One or more values used for filtering, as defined below.
* `zone` - (Optional) The name of zone that the PacketFilter is in (e.g. `is1a`, `tk1a`).

---

A `filter` block supports the following:

* `condition` - (Optional) One or more name/values pairs used for filtering. There are several valid keys, for a full reference, check out finding section in the [SakuraCloud API reference](https://developer.sakura.ad.jp/cloud/api/1.1/).
* `id` - (Optional) The resource id on SakuraCloud used for filtering.
* `names` - (Optional) The resource names on SakuraCloud used for filtering. If multiple values are specified, they combined as AND condition.

---

A `condition` block supports the following:

* `name` - (Required) The name of the target field. This value is case-sensitive.
* `values` - (Required) The values of the condition. If multiple values are specified, they combined as AND condition.
* `operator` - (Optional) The filtering operator. This must be one of following: `partial_match_and`/`exact_match_or`. Default: `partial_match_and`

## Attribute Reference

* `id` - The id of the Packet Filter.
* `description` - The description of the PacketFilter.
* `expression` - One or more `expression` blocks as defined below.
* `name` - The name of the PacketFilter.

---

A `expression` block exports the following:

* `allow` - The flag to allow the packet through the filter.
* `description` - The description of the expression.
* `destination_port` - A destination port number or port range used for filtering (e.g. `1024`, `1024-2048`).
* `protocol` - The protocol used for filtering. This will be one of [`http`/`https`/`tcp`/`udp`/`icmp`/`fragment`/`ip`].
* `source_network` - A source IP address or CIDR block used for filtering (e.g. `<IP_ADDRESS>`, `<IP_ADDRESS>/24`).
* `source_port` - A source port number or port range used for filtering (e.g. `1024`, `1024-2048`).

repository: sacloud/terraform-provider-sakuracloud

gha_language: Go

repo_name: sacloud/terraform-provider-sakuracloud


text:
# The-Dragon-Server

## Backend support for The Dragons Kitchen Web app. An API and Database connection

### Author: Matt Ravenmoore

### Version:

  - 1.0.0 ~~ basic api functionality achived 7/10/2021
  - 1.0.1 ~~ api call to spoon working and returning results 7/12/2021
  - 1.0.2 ~~ can now get details from spoon api. 7/12/2021

### Links and Resources

[Production Front end](https://dragonkitchen.netlify.app/)
[development Front end](https://thedragonskitchen-dev.netlify.app/)
[development Server](https://dragons-server-dev.herokuapp.com/)
[Production server](https://the-dragons-server.herokuapp.com/)

### Setup

1. clone Repo to local.
1. install the Dependancies useing `npm install`
1. setup a mongodb database for local testing see [here](https://docs.mongodb.com/manual/installation/) to go to docs and follow instructions there.
1. set env Variables as follows:
  1. PORT=(normaly 3000 but any will work)
  1. MONGODB_URI=(your mongodb link)
  1. SPOON_API_KEY=(for testing get your own accout its free)

set up your model for what you want your routes to look like and take in data like... se existing Dragons folder under models for an example.

spoonacular api docs  = [spoon](https://spoonacular.com/food-api)

### Endpoints

- '/'  home/welcome/proof of life
- '/api/v1/recipesDB'  gets all recipes in dragon DB
- '/api/v1/recipesDB/:id' gets one by dragon db id
- '/recipe/v1/' search function takes params of
    - search:"thing", type:"query", count:Num
- '/recipe/v1/details/:id' brings up details for recipes

#### How to initialize/run your application (where applicable)

run `npm start` to run localy on what ever port you set up express to take from your env;

#### Tests

testing notes to come

#### UML/site map

repository: M-Ravenmoore/the-dragons-server

repo_name: M-Ravenmoore/the-dragons-server


text:
# AwsIoTSailboat

```text
aws-q2-2023/Resource/IoT/AwsIoTSailboat
```

```text
include('aws-q2-2023/Resource/IoT/AwsIoTSailboat')
```

| Illustration | AwsIoTSailboat | AwsIoTSailboatCard | AwsIoTSailboatGroup |
| :---: | :---: | :---: | :---: |
| ![illustration for Illustration](../../../aws-q2-2023/Resource/IoT/AwsIoTSailboat.png) | ![illustration for AwsIoTSailboat](../../../aws-q2-2023/Resource/IoT/AwsIoTSailboat.Local.png) | ![illustration for AwsIoTSailboatCard](../../../aws-q2-2023/Resource/IoT/AwsIoTSailboatCard.Local.png) | ![illustration for AwsIoTSailboatGroup](../../../aws-q2-2023/Resource/IoT/AwsIoTSailboatGroup.Local.png) |

## Sprites
The item provides the following sriptes:

- `<$AwsIoTSailboatXs>`
- `<$AwsIoTSailboatSm>`
- `<$AwsIoTSailboatMd>`
- `<$AwsIoTSailboatLg>`

## AwsIoTSailboat

### Load remotely
```plantuml
@startuml
' configures the library
!global $LIB_BASE_LOCATION="https://raw.githubusercontent.com/tmorin/plantuml-libs/master/distribution"

' loads the library's bootstrap
!include $LIB_BASE_LOCATION/bootstrap.puml

' loads the package bootstrap
include('aws-q2-2023/bootstrap')

' loads the Item which embeds the element AwsIoTSailboat
include('aws-q2-2023/Resource/IoT/AwsIoTSailboat')

' renders the element
AwsIoTSailboat('AwsIoTSailboat', 'Aws Io T Sailboat', 'an optional tech label', 'an optional description')
@enduml
```

### Load locally
```plantuml
@startuml
' configures the library
!global $INCLUSION_MODE="local"
!global $LIB_BASE_LOCATION="../../.."

' loads the library's bootstrap
!include $LIB_BASE_LOCATION/bootstrap.puml

' loads the package bootstrap
include('aws-q2-2023/bootstrap')

' loads the Item which embeds the element AwsIoTSailboat
include('aws-q2-2023/Resource/IoT/AwsIoTSailboat')

' renders the element
AwsIoTSailboat('AwsIoTSailboat', 'Aws Io T Sailboat', 'an optional tech label', 'an optional description')
@enduml
```

## AwsIoTSailboatCard

### Load remotely
```plantuml
@startuml
' configures the library
!global $LIB_BASE_LOCATION="https://raw.githubusercontent.com/tmorin/plantuml-libs/master/distribution"

' loads the library's bootstrap
!include $LIB_BASE_LOCATION/bootstrap.puml

' loads the package bootstrap
include('aws-q2-2023/bootstrap')

' loads the Item which embeds the element AwsIoTSailboatCard
include('aws-q2-2023/Resource/IoT/AwsIoTSailboat')

' renders the element
AwsIoTSailboatCard('AwsIoTSailboatCard', 'Aws Io T Sailboat Card', 'an optional description')
@enduml
```

### Load locally
```plantuml
@startuml
' configures the library
!global $INCLUSION_MODE="local"
!global $LIB_BASE_LOCATION="../../.."

' loads the library's bootstrap
!include $LIB_BASE_LOCATION/bootstrap.puml

' loads the package bootstrap
include('aws-q2-2023/bootstrap')

' loads the Item which embeds the element AwsIoTSailboatCard
include('aws-q2-2023/Resource/IoT/AwsIoTSailboat')

' renders the element
AwsIoTSailboatCard('AwsIoTSailboatCard', 'Aws Io T Sailboat Card', 'an optional description')
@enduml
```

## AwsIoTSailboatGroup

### Load remotely
```plantuml
@startuml
' configures the library
!global $LIB_BASE_LOCATION="https://raw.githubusercontent.com/tmorin/plantuml-libs/master/distribution"

' loads the library's bootstrap
!include $LIB_BASE_LOCATION/bootstrap.puml

' loads the package bootstrap
include('aws-q2-2023/bootstrap')

' loads the Item which embeds the element AwsIoTSailboatGroup
include('aws-q2-2023/Resource/IoT/AwsIoTSailboat')

' renders the element
AwsIoTSailboatGroup('AwsIoTSailboatGroup', 'Aws Io T Sailboat Group', 'an optional tech label') {
    note as note
        the content of the group
    end note
}
@enduml
```

### Load locally
```plantuml
@startuml
' configures the library
!global $INCLUSION_MODE="local"
!global $LIB_BASE_LOCATION="../../.."

' loads the library's bootstrap
!include $LIB_BASE_LOCATION/bootstrap.puml

' loads the package bootstrap
include('aws-q2-2023/bootstrap')

' loads the Item which embeds the element AwsIoTSailboatGroup
include('aws-q2-2023/Resource/IoT/AwsIoTSailboat')

' renders the element
AwsIoTSailboatGroup('AwsIoTSailboatGroup', 'Aws Io T Sailboat Group', 'an optional tech label') {
    note as note
        the content of the group
    end note
}
@enduml
```

repository: tmorin/plantuml-libs

gha_language: TypeScript

repo_name: tmorin/plantuml-libs


text:
# Alexa Street Address
A node module to parse spoken street addresses into a common format

## Installing
```
npm install --save alexa-street-address
```
## Example
```javascript
const { getFriendlyAddress } = require('alexa-address-parser');

const spokenAddress = '123 northeast 30 first avenue';
try {
  const friendlyAddress = getFriendlyAddress(spokenAddress);
  // equals '123 northeast 31st avenue'
} catch (ex) {
  // format not recognized
}
```

repository: gavinleader/alexa-street-address

repo_name: gavinleader/alexa-street-address


text:
# Hubot as a Service
A systemd service file to start Hubot. Handles reboots and crashes.

###### Getting Started
1. Set ENV variables and location/user in the service file.
2. Place in `/etc/systemd/system`
3. To load the service file: `systemctl daemon-reload`
4. To start the service: `service hubot start`
5. Verify Hubot is active in Slack

###### Viewing Console Output
Hubot's console output is directed to `~/Logs/hubot.log` by default. To change this location, edit the `ExecStart` entry (line 23).
The log is cleared each time the service is ran. If you want to keep a running log, change `>` to `>>` in the `ExecStart` entry (line 23).

###### Updating
To update the service file ---
1. Stop the Hubot service: `service hubot stop`
2. Copy over the new service file or edit the existing one.
3. Reload it: `systemctl daemon-reload`
4. Start it: `service hubot start`
5. Re-verify Hubot is active in Slack

###### Restarting Hubot
To restart Hubot: `service hubot restart`

###### Notes
ENV Variables should not include any quotes or escaping (Correct Example: `Environment=HUBOT_DARK_SKY_DEFAULT_LOCATION=90210`)

For more information on preventing restart loops with StartLimitInterval & StartLimitBurst, [please see the manual](https://www.freedesktop.org/software/systemd/man/systemd.unit.html#StartLimitIntervalSec=).

repository: jonfairbanks/Hubot-as-a-Service

repo_name: jonfairbanks/Hubot-as-a-Service


text:
Steps for reproducing the results:

0. Extract all compressed dependency libraries by running `./install_deps.sh`

1. Schedule generation:

    (under current directory)

    `cd multichip`

    `./generateMitSchedules_mem.sh [batchsize] [wordsize]` (e.g. batchsize=1, wordsize=16 -> ./generateMitSchedules_mem.sh 1 16). You can modify the output directory and the workload by modifying the commented section in this script.

    `./generateMitSchedules_mem_mp.sh [batchsize] [wordsize]` (using the same parameters and workloads above)

    `./generate_MitTraces_mem.sh [batchsize]` [wordsize] (using the same parameters above, set LSTM=True in gen_mem_trace.py if running LSTM workload, False otherwise)

    `python3 create_workloads.py`

    Notes:

    - To change workloads, edit the corresponding mem and net names in these scripts

    - Only 1 net should be simulated at a time

    - Due to limitations of `nn_dataflow`, we need to split the `lstm_langmod` workload by each lstm cell and thus we need to run one simulation for each split workload (`lstm_langmod` and `lstm_langmod_1`)

2. Copy the workloads to the simulation directory by running:

    `cd ..`

    `./copy_multichip_workload.sh`

    `vim workloads.conf` (and enable the corresponding net to be simulated)

3. Kickoff simulation

    `python3 main.py >& log.txt`

4. Analyze results

    `cd sim_results`

    `cp results . -r` (this copies the zsim results to the current folder)

    `cp ../multichip/message_passing . -r` (this copies the chip partition and messages info to the current folder)

    `vim analyze_results.py` (and set the corresponding net name, directory paths and SPLIT (memsize for each chip))

    `python3 analyze_results.py`

    Notes:

    - The script automatically aggregates the LSTM results in the coefficient section if you put `lstm_langmod` and `lstm_langmod_1` together


text:
# bash_async_tasks

Small helper functions to run tasks async on Bash

This lib provides 3 primitives to help run functions on bash asynchronously:

`task_start` `task_run` `task_wait`

This is an example get from `tasks/example.sh`

```bash
__dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

regular_task() {
  echo "$@"
  sleep $(echo $RANDOM % 10 + 1 | bc)
  echo "This message is from ${0}"
}

run() {
  echo "${CYAN}* Run regular_task Multiple times...${NORMAL}"

  task_start

  for i in {0..10}; do
    cmd=(regular_task ${i} "from regular task")
    task_run cmd[@]
  done

  task_wait
}

run
```

The logged output is prefixed with the `pid` that is running the task.

This should produce an output as showed bellow:

![screenshot of simple running example](screenshots/bash_async_tasks_screeshot-1.png "Description goes here")


text:
---
# layout: note_tutorial
title: Database query
catalog: true
tags:
  - API
  - fetch()
permalink: js_api_database_query.html
folder: frontEnd
summary:
# sidebar: api_sidebar
# topnav: topnav
---

This is based on Daniel Shiffman's video tutorial on **Working with Data and APIs in JavaScript**.

## Resource

## Purpose

Make a `GET` request to a route on the server and have the route return all the data from the database.

## Step 1: Eatablish a route

Establish a route on the server and the client sides to make handshake possible.

### 1-A: Client side

```JavaScript
// run function
getData();
// make a function
async function getData() {
  // For a GET request, you don't have to explicitly specify the method, given that GET is the default. You still can still use /api because its GET route are not occupied
  const response = await fetch('api');
  const data = await response.json();
  console.log(data);
}
```

Uptill now, it doesn't really work. You have to complete the route on the server side.

### 1-B: Server side

```JavaScript
app.get('api', (request, response) => {
  response.json({test: 123});
});
```

Restart the node.js service and access the page. You may see the printout on your dev console.

## Step 2: Query the database and find everything

```JavaScript
app.get('/api', (request, response) => {
  database.find({}, (err, data) => { // leave the curly braces empty to find everything in the database
    // error handling
    if (err) {
      response.end();
      return;
    }
    response.json(data);
  });
});
```

## Step 3: Receive and parse data on client

```JavaScript
for (item of data) {
  const root = document.createElement('div'); // root div
  const geo = document.createElement('div'); // accommodate geolocation information
  const date = document.createElement('div'); // accommodate date information

  // Add text to div elements:
  geo.textContent = `Latitude: ${item.lat}°, Longitude: ${item.lon}°`
  // Covert timestamp to readable date strings:
  const dateString = new Date(item.timestamp).toLocalString();
  date.textContent = `Date: ${dateString}`;

  // specify the hierarchy position of the three div elements
  root.append(geo, date);
  document.body.append(root);
};
```


text:
![](Assets/logo.png)

# Taylor

⚠ **Taylor is DEPRECATED. Use [SwiftLint](https://github.com/realm/SwiftLint) instead.**

A tool aimed to increase Swift code quality, by checking for conformance to code metrics.

[![Build Status](https://travis-ci.org/yopeso/Taylor.svg?branch=master)](https://travis-ci.org/yopeso/Taylor)
[![codecov.io](https://codecov.io/github/yopeso/Taylor/coverage.svg?branch=master)](https://codecov.io/github/yopeso/Taylor?branch=master)
[![Release version](https://img.shields.io/badge/release-0.2.3-blue.svg)](https://github.com/yopeso/Taylor/releases/tag/0.2.3)
[![Swift Code](https://img.shields.io/badge/language-swift-orange.svg)](https://github.com/yopeso/Taylor)
[![Platform](https://img.shields.io/badge/platform-osx-yellow.svg)](https://github.com/yopeso/Taylor)
[![License](https://img.shields.io/badge/license-MIT-lightgrey.svg)](https://github.com/yopeso/Taylor/blob/master/LICENSE)

Taylor uses [SourceKitten](https://github.com/S2dentik/SourceKitten) to a more
accurate [AST](http://clang.llvm.org/docs/IntroductionToTheClangAST.html)
representation and generates the final report in either **Xcode, JSON, PMD** or **plain text** formats.

## Installation

### Homebrew (recommended)
You need to have [Homebrew](http://brew.sh) installed.
```shell
brew update
brew install taylor
```
### Source
Rebuild dependencies by running `carthage bootstrap --platform Mac` ([Carthage](https://github.com/Carthage/Carthage) required)
Clone the project and run `make install` (**latest version of Xcode required**).

### Package
Download the latest [release](https://github.com/yopeso/Taylor/releases) and run:
```shell
Taylor.app/Contents/Resources/install
```

## Usage

### Xcode

To get warnings displayed in the IDE add a new **Run Script Phase** with:

```bash
if which taylor >/dev/null; then
  taylor -p ${PROJECT_DIR} -r xcode
else
  echo "Taylor not installed"
fi
```
![](Assets/runscriptphase.png)

### Command line

To use Taylor from command line run it as follows:

`taylor [option1 [option1_argument]] [option2 option2_argument] […]`

##### Available options

|`taylor`           |Description|
|----------------|-------------------|
|`-h`/`--help`| Print **help**.|
|`-v`/`--version`| Print Taylor **version**.|
|`-p`/`--path` `path`| **Path** to the folder to be analysed (current folder by default).|
|`-e`/`--exclude` `file`| Path to either **directory or file to be excluded** from analysis.|
|`-ef`/`--excludeFile` `file`| Path to **exclude file** in `.yml` format.|
|`-f`/`--file` `file`| File to be **included** in analysis (may be from an external source).|
|`-t`/`--type` `type`| **Type of files** to be analysed.|
|`-vl`/`--verbosityLevel` `level`| **Verbosity level** for output messages (info, warning and error).|
|`-r`/`--reporter` `type:name`| Type of final report (**json, xcode, pmd** or **plain text**) and filename.|
|`-rc`/`--ruleCustomization` `rule=value`| **Customize rules** by giving custom values. See [help](/Resources/Help.txt) for more details.|

`taylor` alone with **no arguments** analyses `.swift` files inside current folder.

### Excludes

If you want to exclude some files or folders from checking create a new `.yml` file and call Taylor with
`-ef /path/to/file` argument.
Default filename is `excludes.yml` and its default location is the folder
specified by `--path` flag.
The following excluding name formats can be specified:

```yaml
- "/path/to/file"
- "file"
- "Folder"
- "Folder/*"
- ".*Tests.*"
```

### Rules

These are the code quality rules currently existing:

#### Excessive Class Length

[Number of lines in a class]("http://phpmd.org/rules/codesize.html#excessiveclasslength") must not exceed given limit. Default limit = `400 lines`.
Example: `taylor -rc ExcessiveClassLength=100`.

#### Excessive Method Length

[Number of lines in a method]("http://phpmd.org/rules/codesize.html#excessivemethodlength") must not exceed given limit. Default limit = `20 lines`.
Example: `taylor -rc ExcessiveMethodLength=10`.

#### Too Many Methods

[Number of methods in a class]("http://phpmd.org/rules/codesize.html#toomanymethods") must not exceed given limit. Default limit = `10 methods`.
Example: `taylor -rc TooManyMethods=7`.

#### Cyclomatic Complexity

[Cyclomatic Complexity](http://phpmd.org/rules/codesize.html#cyclomaticcomplexity) number of a method must not exceed maximal admitted value. Default = `5`.
Example: `taylor -rc CyclomaticComplexity=10`.

#### Nested Block Depth

[Block Depth](http://docs.oclint.org/en/dev/rules/size.html#nestedblockdepth) of a method must not exceed maximal admitted value. Default = `3`.
Example: `taylor -rc NestedBlockDepth=7`.

#### N-Path Complexity

[N-Path Complexity](http://phpmd.org/rules/codesize.html#npathcomplexity) of a method must not exceed maximal admitted value. Default = `100`.
Example: `taylor -rc NPathComplexity=50`.

#### Excessive Parameter List

[Number of parameters](http://phpmd.org/rules/codesize.html#excessiveparameterlist) given to a method must not exceed maximal admitted value. Default = `3`.
Example: `taylor -rc ExcessiveParameterList=5`.

## Credits

Thanks to [JP Simard](https://github.com/jpsim) for developing [SourceKitten](https://github.com/jpsim/SourceKitten).

## License

MIT Licensed.

gha_language: Swift


text:
# elasticsearch-bitbucket-pipelines
Use elasticsearch in development mode in bitbucket-pipelines

Elasticsearch [requires the discovery.type environment variable to be run in dev mode.](https://www.elastic.co/guide/en/elasticsearch/reference/current/docker.html#docker-cli-run-dev-mode)

As of May 2020, [Bitbucket still does not support variable names with periods in them.](https://jira.atlassian.com/browse/BCLOUD-18007)

This packages that environment variable with the official elasticsearch 7.7.0 image.


text:
---
id: index
title: Overview
---

_This section is intended for system administrators of installations of dbt Cloud into Enterprise customers' cloud providers. For access to dbt Cloud's on premises offering, [please contact our sales team](mailto:sales@getdbt.com)._

dbt Cloud is bundled a Kubernetes appliance that can be automatically installed into a standalone Kubernetes cluster.

dbt Cloud uses a collection of open source technologies called Kubernetes-off-the-shelf ([KOTS](https://kots.io/)) to manage installations. Internally, dbt Cloud is a Kubernetes appliance, but you do not need to already use Kubernetes to run it. It supports two different deployment models: installation into an existing Kubernetes cluster, or installation onto a bare Linux instance or VM.


text:
# CondInst

> [CondInst: Conditional Convolutions for Instance
> Segmentation](https://arxiv.org/pdf/2003.05664.pdf)

## Abstract

We propose a simple yet effective instance segmentation framework, termed CondInst (conditional convolutions for instance segmentation). Top-performing instance segmentation methods such as Mask
R-CNN rely on ROI operations (typically ROIPool or ROIAlign) to
obtain the final instance masks. In contrast, we propose to solve instance segmentation from a new perspective. Instead of using instancewise ROIs as inputs to a network of fixed weights, we employ dynamic
instance-aware networks, conditioned on instances. CondInst enjoys two
advantages: 1) Instance segmentation is solved by a fully convolutional
network, eliminating the need for ROI cropping and feature alignment.
2\) Due to the much improved capacity of dynamically-generated conditional convolutions, the mask head can be very compact (e.g., 3 conv.
layers, each having only 8 channels), leading to significantly faster inference. We demonstrate a simpler instance segmentation method that can
achieve improved performance in both accuracy and inference speed. On
the COCO dataset, we outperform a few recent methods including welltuned Mask R-CNN baselines, without longer training schedules needed.

## Results and Models

| Backbone |  Style  | MS train | Lr schd | bbox AP | mask AP |                          Config                           |                                                                                Download                                                                                |
| :------: | :-----: | :------: | :-----: | :-----: | :-----: | :-------------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
|   R-50   | pytorch |    Y     |   1x    |  39.8   |  36.0   | [config](./condinst_r50_fpn_ms-poly-90k_coco_instance.py) | [model](https://download.openmmlab.com/mmdetection/v3.0/condinst/condinst_r50_fpn_ms-poly-90k_coco_instance/condinst_r50_fpn_ms-poly-90k_coco_instance_20221129_125223-4c186406.pth) \| [log](https://download.openmmlab.com/mmdetection/v3.0/condinst/condinst_r50_fpn_ms-poly-90k_coco_instance/condinst_r50_fpn_ms-poly-90k_coco_instance_20221129_125223.json) |

## Citation

```latex
@inproceedings{tian2020conditional,
  title     =  {Conditional Convolutions for Instance Segmentation},
  author    =  {Tian, Zhi and Shen, Chunhua and Chen, Hao},
  booktitle =  {Proc. Eur. Conf. Computer Vision (ECCV)},
  year      =  {2020}
}
```

repository: alldatacenter/alldata

repo_name: alldatacenter/alldata


text:
---
date: 2000-01-01T00:00:00+00:00
title: Plugin Cards
author: eoinmcafee
weight: 3
---

# Drone Announces User Interface Plugins, Powered by Microsoft Adaptive Cards

A powerful new feature that allows Drone Plugins to extend the Build Execution view and provide pertinent information of their execution.

Plugin Cards allow Drone users to get high level insights into their build’s execution, and enables them to detect potential issues faster.

Plugin Cards will automatically appear in the build’s execution view, at the end of the plugin execution, if a supported plugins is used.

## What does a card look like

Different plugins will have different visualizations depending on the type of data presented.
Here is an example of what a card for the Docker plugin looks like :

![Card](/screenshots/card.png)

This card allows you to see, at a glance, all of the important information pertaining to the image generated during the execution of the docker plugin.

## Supported Versions

- Drone Server - v2.6.0+
- Drone Runner Docker - v1.8.0+ / Drone Kubernetes Runner - latest

## Supported plugins

- Drone-docker
- Snyk
- Gitleaks

# How do I add adaptive cards support to my plugin?

Plugin Cards are built upon the open adaptive cards format . This makes it much easier for a plugin developer to add enhanced output functionality without requiring any changes to the Drone Server.

A card is made up of a template (what the user sees) and output from a plugin (raw data from the build). These are combined by Drone to display the card in the Drone UI.

During the plugin’s execution, Drone downloads the plugin template. An example of what a template looks like can be found here and it is downloaded when rendering the card.

Below is the JSON payload that is generated by the docker plugin. This is the raw information that appears on the card:

```yaml {linenos=table}
{
    "Id": "sha256:d9437eae98f2787931b0fae86cc79c3993cd3ed031f84f67a41fdff5bcb436c9",
    "RepoTags": ["drone-test:latest", "5699c94024237b8b4838717f4f7a55d55cab66bb:latest"],
    "RepoDigests": ["drone-test@sha256:2ab4cd8ec41a0f7d68c34289a52dffa4d483abbdd10bcd68fd4da3e904a81f76"],
    "Parent": "sha256:bdca5d527305e375f37d177e745224d0d7fce56eb1454210d9a6f2441a40d31b",
    "Comment": "",
    "Created": "2022-01-05T12:04:34.3483105Z",
    "Container": "eafafc780d73493be11f546777ff303341b2094671b244ed804eff49a722d40a",
    "DockerVersion": "20.10.9",
    "Author": "",
    "Architecture": "amd64",
    "Os": "linux",
    "Size": 186298129,
    "VirtualSize": 186298129,
    "Metadata": {
        "LastTagTime": "2022-01-05T12:04:34.392555Z"
    }
}
```

# Adding Drone card functionality to a plugin

## Creating a template

To get started you first want to think about the information you wish to display on-screen & how it should look. This becomes the card template. The easiest way to create it is by using this adaptive cards designer.

The docker template in this example is hosted and served using Github pages.

Mention the directory structure of the plugin

- /docs/template.json
- /docs/sample_data.json

## Card Input

This assumes that your plugin has been written in Golang but it could be written in any other language. As long as the JSON output is created correctly.

The structure of a card struct is as follows. This is what is written to the logs for the runner to extract and publish information to the Drone server.

```go {linenos=table}
CardInput struct {
    Schema string          `json:"schema"` // template url
    Data   json.RawMessage `json:"data"` // template data
}
```

The following encodes the card data in order for the runner to extract it from the logs:

```go {linenos=table}
func writeCardTo(out io.Writer, data []byte) {
    encoded := base64.StdEncoding.EncodeToString(data)
    io.WriteString(out, "\u001B]1338;")
    io.WriteString(out, encoded)
    io.WriteString(out, "\u001B]0m")
    io.WriteString(out, "\n")
    }
}
```

This code allows the plugin to support both CI & Drone. Once the card input struct has been created, it must be written to “dev/stdout”.

```go {linenos=table}
func writeCard(path string, card interface{}) {
    data, _ := json.Marshal(card)
    switch {
    case path == "/dev/stdout":
        writeCardTo(os.Stdout, data)
    case path == "/dev/stderr":
        writeCardTo(os.Stderr, data)
    case path != "":
        ioutil.WriteFile(path, data, 0644)
    }
}
```

Once the input data is written, the runner & Drone server will do the rest and in the build screen, a card should appear.

repository: drone/docs

gha_language: SCSS

gha_license_id: NOASSERTION

repo_name: drone/docs


text:
# zita-resampler-callback
Callback-based API for Zita-resampler

# Usage

The API is a convenience wrapper around Zita-resampler.

Instead of filling a buffer with source rate signal, a callback is invoked as needed, and the buffering logic is handled transparently.

`ResamplerByCallback` and `VResamplerByCallback` are respective counterparts of `Resampler` and `VResampler`.

Setup parameters are:

| Parameter | Description |
| --------- | ----------- |
| generator *gen | callback function which produces source frames |
| void *cookie | user data to callback function |
| unsigned bsize | maximum frame count to request from the callback |

repository: jpcima/zita-resampler-callback

repo_name: jpcima/zita-resampler-callback


text:
## Introduction

`svFSI` is a  multi-physics finite element solver designed for computational modeling of the cardiovascular system. Some of the unique capabilities of `svFSI` include modeling cardiac electrophysiology, biological tissue mechanics, blood flow, and large deformation fluid-structure interaction (FSI). `svFSI` also offers a wide choice of boundary conditions for performing patient-specific modeling of cardiovascular biomechanics. The code is parallelized using message-passing-interface (MPI) and offers multiple options to choose a linear solver and preconditioner. `svFSI` can be used as part of the [SimVascular](https://simvascular.github.io) software or can be used as a stand-alone solver.

## Dependence

The following packages are required to build and use `svFSI`.
   - cmake
   - cmake-curses-gui
   - cmake-gui
   - gcc (version>=4.8.5) with gfortran
   - openmpi or mpich
   - blas & lapack
   - trilinos (optional)

On Ubuntu, most of the dependencies can be installed using `apt install`. On macOS, the dependencies may be installed using `brew`. Apart from GNU compilers, `svFSI` can also be built with Intel oneAPI Toolkits. For more details, please refer to [`INSTALL.md`](./INSTALL.md#Build) and [`INSTALL-DEPS.md`](./INSTALL-DEPS.md#intel-oneapi-toolkitsd).

## Quick Build

Precompiled binaries for Ubuntu and MacOS are available for download from [SimTK](https://simtk.org/frs/index.php?group_id=188).

Users are recommended to build from the source code to access the most recent features and bug fixes. Instructions for a quick build are provided here for a Linux/Mac OS system.

1. Clone or download the current repository.
2. Create a `build` directory
   ```bash
   cd svFSI && mkdir build && cd build
   ```
3. Initiate the CMake terminal interface to generate makefiles.
   ```bash
   ccmake ..
   ```
4. This will automatically search for compilers. Follow instructions if necessary. Press “c” to configure repeatedly until CMake parameters no longer change and CMake presents the option “g” to generate. Press “g” to create makefiles and exit. Run `make` in the build directory:
   ```bash
   make
   ```
   A successful build will generate a solver binary, called `svFSI` in the following directory `build/svFSI-build/bin`.

   For more advanced users, please refer [`INSTALL.md`](./INSTALL.md) for detailed platform-specific instructions to install `svFSI`.

## Build With Trilinos

`svFSI` also supports compilation with [Trilinos](https://github.com/trilinos/Trilinos). Users can build Trilinos locally following its [online documentation](https://docs.trilinos.org/files/TrilinosBuildReference.html).

The recommended Trilinos third-party libraries (TPLs) include Boost, BLAS, HDF5, HYPRE, LAPACK, MPI, and MUMPS. The required Trilinos packages are Amesos, AztecOO, Epetra, EpetraEXT, Ifpack, ML, MueLU, ROL, Sacado, Teuchos, and Zoltan.

To enable Trilinos in `svFSI`, users need to turn on the option `SV_USE_TRILINOS` located in the file [`Code/CMake/SimVascularOptions.cmake`](./Code/CMake/SimVascularOptions.cmake) as,

```bash
option(SV_USE_TRILINOS "Use Trilinos Library with svFSI" ON)
```

In most cases, users can proceed to build `svFSI` following the [Quick Build](#quick-build), and CMake should be able to locate Trilinos automatically through `find_package`. In case the automatic way fails, users can also specify the path to Trilinos through `ccmake -DCMAKE_PREFIX_PATH:PATH="<Path_to_Trilinos>/lib/cmake/Trilinos;<Path_to_any_other_package>;"`.

For more detailed instructions, please refer INSTALL.md.

## Run Simulation

`svFSI` requires a plain-text input file to specify simulation parameters. The syntax of the input file can be found [here](https://sites.google.com/site/memt63/tools/MUPFES/mupfes-scripting).

A master template is provided in the current repository, [svFSI_master.inp](./svFSI_master.inp). Users are also recommended to go through the input files in the [examples](https://github.com/SimVascular/svFSI-Tests) and modify them for their needs.

An MPI-based run can be initiated through
```bash
mpiexec -np <number of MPI processes>  <Path to Build>/svFSI-build/bin/svFSI <Path to input file>
```
## Features

`svFSI` provides the capability to model a variety of physics including unsteady diffusion, linear and nonlinear elastodynamics, convective heat transfer, fluid flows, fluid-structure-interaction (FSI), and cardiac electrophysiology. As the code is modular, the users are provided with a choice to couple these physics depending on their needs. We strongly recommend users to browse through the examples provided in the GitHub repository [svFSI-Tests](https://github.com/SimVascular/svFSI-Tests) to get a detailed insight into the capability of the code.

Below, we provide a list of the available choice of constitutive models for different types of equations being solved. Users are also encouraged to implement new constitutive models. Users may use global search tools such as `grep` to locate the implementations of the available constitutive models in the code using the abbreviated names below.

*Abbreviation* refers to the variable name in the source code; *Full name* refers to the generic name of the model; *Input keyword* refers to the phrase in the input file that can invoke such model.

1. Available isochoric constitutive models for the structure equation
   | *Abbreviation* | *Full name*                        | *Input keyword*                                         |
   | -------------- | ---------------------------------- | ------------------------------------------------------- |
   | stIso\_stVK    | Saint Venant-Kirchhoff             | "stVK", "stVenantKirchhoff"                             |
   | stIso\_mStVK   | modified Saint Venant-Kirchhoff    | "m-stVK", "modified-stVK", "modified-stVenantKirchhoff" |
   | stIso\_nHook   | Neo-Hookean model                  | "nHK", "nHK91", "neoHookean", "neoHookeanSimo91"        |
   | stIso\_MR      | Mooney-Rivlin model                | "MR", "Mooney-Rivlin"                                   |
   | stIso\_HGO_d   | Holzapfel-Gasser-Ogden (decoupled) | "HGO", "HGO-d", HGO-decoupled"                          |
   | stIso\_HGO_ma  | HGO model (modified anisotropy)    | "HGO-ma", "HGO-modified"                                |
   | stIso\_Gucci   | Guccione model                     | "Guccione", "Gucci"                                     |
   | stIso\_HO_d    | Holzapfel-Ogden model (decoupled)  | "HO", "Holzapfel", "HO-decoupled", "HO-d"               |
   | stIso\_HO_ma   | HO model (modified anisotropy)     | "HO-ma", "HO-modified"                                  |

2. Available volumetric constitutive models for the structure equation
   | *Abbreviation* | *Full name*         | *Input keyword*                          |
   | -------------- | ------------------- | ---------------------------------------- |
   | stVol\_Quad    | Quadratic model     | "quad", "Quad", "quadratic", "Quadratic" |
   | stVol\_ST91    | Simo-Taylor91 model | "ST91", "Simo-Taylor91"                  |
   | stVol\_M94     | Miehe94 model       | "M94", "Miehe94"                         |

3. Available constitutive models for the fluid equation
   | *Abbreviation*  | *Full name*                          | *Input keyword*                  |
   | --------------- | ------------------------------------ | -------------------------------- |
   | viscType\_Const | Constant viscosity (Newtonian model) | "Constant", "Const", "Newtonian" |
   | viscType\_CY    | Carreau-Yasuda non-Newtonian model   | "Carreau-Yasuda", "CY"           |
   | viscType\_Cass  | Cassons non-Newtonian model          | "Cassons", "Cass"                |

4. Available cardiac electrophysiology models
   | *Abbreviation* | *Full name*                      | *Input keyword*               |
   | -------------- | -------------------------------- | ----------------------------- |
   | cepModel\_AP   | Aliev-Panfilov model             | "AP", "Aliev-Panfilov"        |
   | cepModel\_BO   | Bueno-Orovio-Cherry-Fenton model | "BO", "Bueno-Orovio"          |
   | cepModel\_FN   | Fitzhugh-Nagumo model            | "FN", "Fitzhugh-Nagumo"       |
   | cepModel\_TTP  | tenTusscher-Panfilov model       | "TTP", "tenTusscher-Panfilov" |

## Additional Resource
More details can be found here:
- Fluid-Structure Interaction (FSI): https://simvascular.github.io/docssvFSI.html
- SimCardio: http://simvascular.github.io/docsSimCardio.html
- Cardiac electrophysiology modeling: http://simvascular.github.io/docsSimCardio.html#cep-modeling
- Cardiac mechanics modeling:  http://simvascular.github.io/docsSimCardio.html#mechanics-modeling
- Prescribed-motion LV modeling: https://simvascular.github.io/docsSimCardio.html#automatic-cardiac-modeling

## Citation
In preparation.

gha_language: Fortran


text:
---
title: Synchronized Volume Snapshots for Distributed Workloads on Kubernetes
date: 2021-01-14T18:10:48.848Z
featuredBlog: true
priority: 6
author: Michael Mattsson
authorimage: /img/blogs/Avatar3.svg
thumbnailimage: null
tags:
  - hpe-nimble-storage
  - hpe-3par-and-primera
  - hpe-greenlake
  - hpe-greenlake-for-private-cloud-enterprise
  - hpe-greenlake-for-private-cloud-enterprise-containers
  - developer
  - containers-service
---
Typically, Persistent Volume Claims on Kubernetes are treated as a singular entity completely decoupled from your workload. The actual physical location doesn't really matter. But what if you wanted an atomic operation where all Persistent Volume Claims that make up an application in a microservice architecture need to be atomically protected to ensure referential integrity? Would you stop the application, sequence the operation or take a shotgun approach and hope for the best?

In this blog post, we'll use the HPE CSI Driver for Kubernetes to create Volume Groups that allow users to group Persistent Volume Claims together and use those Volume Groups to perform CSI Volume Snapshots through Snapshot Groups.

In other storage infrastructure management systems, the term "Volume Groups" is usually referred to as "Consistency Groups". It is the industry standard to create volume snapshots with referential integrity. This capability was introduced in the HPE CSI Driver for Kubernetes v1.4.0 and more information about the release may be found on [Around The Storage Block](https://community.hpe.com/t5/Around-the-Storage-Block/HPE-CSI-Driver-for-Kubernetes-v1-4-0-with-expanded-ecosystem-and/ba-p/7118180).

# TL;DR

A variant of the demonstrative steps below has been captured in a screencast that is available on YouTube. If you prefer watching and listening instead of reading, please go ahead and watch the screencast.

Just don’t forget to come back to read the "Learn more" section at the end of this article for important information.

[![Synchronize Volume Snapshots for Distributed Workloads using the HPE CSI Driver for Kubernetes](https://hpe-developer-portal.s3.amazonaws.com/uploads/media/2020/12/untitled-1610648109128.png)](https://youtu.be/zUj-bJ_KqHU "Synchronize Volume Snapshots for Distributed Workloads using the HPE CSI Driver for Kubernetes")
Watch on [YouTube](https://youtu.be/zUj-bJ_KqHU)!

# Prerequisites

The examples we're going to walk through require that the HPE CSI Driver for Kubernetes v1.4.0 or later has been installed along with the CSI external snapshotter. Examples also assume a `VolumeSnapshotClass` named "hpe-snapshot" exists on the cluster.

- Install the HPE CSI Driver using the [Helm Chart](https://artifacthub.io/packages/helm/hpe-storage/hpe-csi-driver)
- Enable [CSI snapshots](https://scod.hpedev.io/csi_driver/using.html#enabling_csi_snapshots)
- Add a [HPE storage backend](https://scod.hpedev.io/csi_driver/deployment.html#add_a_hpe_storage_backend)
- Create a [VolumeSnapshotClass](https://scod.hpedev.io/csi_driver/using.html#using_csi_snapshots) and of course a [StorageClass](https://scod.hpedev.io/csi_driver/using.html#base_storageclass_parameters)

No particular parameters are needed in either the `VolumeSnapshotClass` or `StorageClass` but the backend `Secret` is assumed to be named "hpe-backend" and reside in the "hpe-storage" `Namespace`.

In the examples below, we're using HPE Nimble Storage. Any Container Storage Provider (CSP) will work that supports `VolumeGroups` and `SnapshotGroups`.

# Pick an application

In order to illustrate the fact that multiple snapshots are being created, either pick an application that requires multiple volumes or deploy a microservice stack comprised of multiple stateful applications. In this example we'll use WordPress from the `bitnami/wordpress` Helm Chart.

We're using the following "values" file for the deployment:

```yaml
mariadb:
  architecture: replication
```

Add the Bitnami repo:

```markdown
helm repo add bitnami https://charts.bitnami.com/bitnami
```

Install the WordPress chart:

```markdown
helm install my-wordpress bitnami/wordpress -f wp-values.yaml
```

Once deployed, there should be three `PersistentVolumeClaims` on the cluster.

```markdown
kubectl get pvc -o name
persistentvolumeclaim/data-my-wordpress-mariadb-primary-0
persistentvolumeclaim/data-my-wordpress-mariadb-secondary-0
persistentvolumeclaim/my-wordpress
```

Adding content to the WordPress site being deployed is completely optional as restore procedures are not covered in this tutorial. However, if you're interested in performing a restore from the `VolumeSnapshots` we're creating, please see the CSI snapshots tutorial in this [HPE DEV blog post](/blog/PklOy39w8NtX6M2RvAxW/hpe-csi-driver-for-kubernetes-snapshots-clones-and-volume-expansion).

# Volume Groups

The `CustomResourceDefinition` (CRD) that users interact with is called a `VolumeGroup`. In order to facilitate the creation of `VolumeGroups` a Kubernetes cluster administrator needs to create another `CRD` called a `VolumeGroupClass`.

The Volume Group Provisioner (depicted below) is a Kubernetes CSI sidecar container that performs a number of duties to facilitate volume grouping.

![picture3](https://hpe-developer-portal.s3.amazonaws.com/uploads/media/2020/12/groups-1610651079691.png)

The `VolumeGroupContent` `CRD` is managed solely by the Volume Group Provisioner.

Let's start by creating a `VolumeGroupClass`. The remaining YAML in this tutorial is assumed to be pasted into a terminal verbatim, like this:

```markdown
kubectl create -f- <hit ENTER>
< paste the YAML content >
^D <hit CTRL+D on a new line>
```

Let's begin:

```yaml
---
apiVersion: storage.hpe.com/v1
kind: VolumeGroupClass
metadata:
  name: my-volume-group-class
provisioner: csi.hpe.com
deletionPolicy: Delete
parameters:
  description: "HPE CSI Driver for Kubernetes Volume Group"
  csi.hpe.com/volume-group-provisioner-secret-name: hpe-backend
  csi.hpe.com/volume-group-provisioner-secret-namespace: hpe-storage
```

At this stage nothing has been created on the backend storage system. The next step is to create a blank `VolumeGroup`.

```yaml
---
apiVersion: storage.hpe.com/v1
kind: VolumeGroup
metadata:
  name: my-volume-group
spec:
  volumeGroupClassName: my-volume-group-class
```

Now, logging in to the backend HPE Nimble Storage array, we'll see a new Volume Collection has been created.

```markdown
Nimble OS $ volcoll --list
--------------------+---------------+-------------------------------------------
Volume Collection    Application     Owned By
Name                 Synchronization
--------------------+---------------+-------------------------------------------
volumegroup-e96aa858-93e9-424c-a593-6a6f216368c0 none            nva-grp
```

Inspecting further:

```markdown
Nimble OS $ volcoll --info volumegroup-e96aa858-93e9-424c-a593-6a6f216368c0
Name: volumegroup-e96aa858-93e9-424c-a593-6a6f216368c0
Description: HPE CSI Driver for Kubernetes Volume Group
Owned by: nva-grp
Application synchronization: none
Application server: N/A
Application ID: N/A
Cluster name: N/A
Service name: N/A
VMware vCenter hostname: N/A
VMware vCenter username: N/A
VMware vCenter password: N/A
Backup agent hostname: N/A
Backup agent username: N/A
Backup agent password: N/A
Associated volumes: none
Associated pinned volumes: none
Snapshot collection count: 0
Created: Jan 13 2021 16:40:48
Last configuration change: Jan 13 2021 16:40:48
Replication Type: Periodic Snapshot
Synchronous Replication State: N/A
Synchronous Replication Last In Sync: N/A
Synchronous Replication Resync %: N/A
```

Adding members to the `VolumeGroup` is done by adding annotations to `PersistentVolumeClaims`. This can be done in a number of ways. Either the claims may be created with the annotation, using the `kubectl patch` command and the `kubectl annotate` command. I prefer using the `kubectl annotate` command. Let's do it.

```markdown
kubectl annotate pvc/data-my-wordpress-mariadb-primary-0 \
  pvc/data-my-wordpress-mariadb-secondary-0 \
  pvc/my-wordpress \
  csi.hpe.com/volume-group=my-volume-group
```

Annotations doesn't need to be created all at once. They can be added (or removed) individually.

At this stage you can inspect the `VolumeGroup` on the Kubernetes cluster or the Volume Collection on the array to confirm that `PersistentVolumeClaims` have been added to the `VolumeGroup`.

```markdown
kubectl get -o yaml volumegroup/my-volume-group \
  -o 'jsonpath={.spec.persistentVolumeClaimNames[*]}'
```

Next, let's create some atomic `VolumeSnapshots`.

# Snapshot Groups

The `SnapshotGroup` `CRD` is primarily what users interact with. The Snapshot Group Snapshotter depicted below carries out all the backend work and populates Kubernetes with the necessary `CRDs`.

![picture4](https://hpe-developer-portal.s3.amazonaws.com/uploads/media/2020/12/snaps-1610647869530.png)

In a similar fashion to `VolumeGroupClasses` a `SnapshotGroupClass` needs to be created by an administrator.

```yaml
---
apiVersion: storage.hpe.com/v1
kind: SnapshotGroupClass
metadata:
  name: my-snapshot-group-class
snapshotter: csi.hpe.com
deletionPolicy: Delete
parameters:
  csi.hpe.com/snapshot-group-snapshotter-secret-name: hpe-backend
  csi.hpe.com/snapshot-group-snapshotter-secret-namespace: hpe-storage
```

Now, users may create `SnapshotGroups`. Upon creation, the `SnapshotGroups` will automatically be populated by `VolumeSnapshots` by the Snapshot Group Snapshotter. Let's create a `SnapshotGroup` and see.

```yaml
---
apiVersion: storage.hpe.com/v1
kind: SnapshotGroup
metadata:
  name: my-snapshot-group-1
spec:
  source:
    kind: VolumeGroup
    apiGroup: storage.hpe.com
    name: my-volume-group
  snapshotGroupClassName: my-snapshot-group-class
  volumeSnapshotClassName: hpe-snapshot
```

While unrelated to this tutorial, the "hpe-snapshot" `VolumeSnapshotClass` should already exist on the cluster as described in the prerequisites above. The `.spec.source` indicates our previously created `VolumeGroup` to snapshot. Now, let's check for `VolumeSnapshots`.

```markdown
kubectl get volumesnapshots -o name
volumesnapshot.snapshot.storage.k8s.io/my-snapshot-group-1-data-my-wordpress-mariadb-primary-0
volumesnapshot.snapshot.storage.k8s.io/my-snapshot-group-1-data-my-wordpress-mariadb-secondary-0
volumesnapshot.snapshot.storage.k8s.io/my-snapshot-group-1-my-wordpress
```

Presto! Further, logging in to the backend array, we can now see a new Snapshot Collection with populated entries.

```markdown
Nimble OS $ snapcoll --list
--------------------+---------------------------------------+-------+-----------
Volume Collection    Snapshot Collection                     Num     Replication
Name                 Name                                    Snaps   Status
--------------------+---------------------------------------+-------+-----------
volumegroup-e96aa858-93e9-424c-a593-6a6f216368c0 snapshot-fde72bb7-6633-4e6f-841c-3efaa0444710      3 N/A
```

A few points to note.

- `SnapshotGroups` may be deleted from the cluster and will in turn delete the `VolumeSnapshots` and backend Snapshot Collection
- `VolumeSnapshots` may be used to perform restores (clone) from as any other `VolumeSnapshot`

# Learn more

This is just the tip of the iceberg when it comes to data management innovation from HPE. Stay tuned to the [HPE Developer Community](https://developer.hpe.com/) to learn more about upcoming features and capabilities.

- Explore the HPE CSI Driver for Kubernetes [on GitHub](https://github.com/hpe-storage/csi-driver)
- Check out the release announcement on [Around The Storage Block](https://community.hpe.com/t5/Around-the-Storage-Block/HPE-CSI-Driver-for-Kubernetes-v1-4-0-with-expanded-ecosystem-and/ba-p/7118180)
- Install the latest HPE CSI Driver using the [Helm Chart from ArtifactHub.io](https://artifacthub.io/packages/helm/hpe-storage/hpe-csi-driver)
- Visit the [HPE Storage Container Orchestration Documentation](https://scod.hpedev.io) (SCOD) portal for everything pertaining to the HPE CSI Driver
- Sign up for a [HPE DEV Hack Shack Workshop](/hackshack/workshops) to learn about CSI on the HPE Ezmeral Container Platform

HPE is eager to learn what our customers and partners are doing with Kubernetes and data management. Join the HPE DEV Slack community to share your thoughts and engage with the team. Sign up at [slack.hpedev.io](http://slack.hpedev.io) and sign in at [hpedev.slack.com](http://hpedev.slack.com), we hang out in #nimblestorage, #3par-primera and #kubernetes.

repository: hpe-dev-incubator/hpe-dev-portal

gha_language: HTML

repo_name: hpe-dev-incubator/hpe-dev-portal


text:
drunken-adventure
=================

A Genetic Algorithm implementation for Travelling sales man problem using structure information of genes.

here is how to run the code:
1. Extract the tsp.zip to folder
2. Use any IDE to open the project
3. right click class file Tsp.java and run.

the program runs for 26 cities. You can for 42 and 48 cities, but before that you have to do some minor coding changes. for example to run for 42 cities:
1. In the Tsp class ,go loadData method (line no: 126), change the "cities26.txt" to "cities42.txt" and like wise for 48 cities .
2.change costant CITY_NUM to reflect the number of cities, for example for 26 cities it is 26, for 42 its 42 and likewise.

the program writes a log into file called graph.log, this can be used produce live graphs for each generation of population.
for example it can be used with LiveGraph:http://www.live-graph.org/

repository: janaganh/genetic-travelling-salesman

repo_name: janaganh/genetic-travelling-salesman


text:
# Style Transfer Deep Neural Network
## Introduction
CNN are some of the most powerfull tools for images classification and Analysis. They process visual image in a feed forward manner passing an input image through a collection of image filters which extract some of the features from the input image.

In this I'll be building the Style Transfer Algorithm. Style Transfer allows us to apply style of one image onto another image of your choice.
Trained CNN to extract style of one image and apply on other image.

## **Reference**
[Image Style Transfer Using Convolutional Neural Networks](https://www.cv-foundation.org/openaccess/content_cvpr_2016/papers/Gatys_Image_Style_Transfer_CVPR_2016_paper.pdf)

In this paper style transfer uses the features found in the 19 layer VGG Network (VGG19). This network accepts a color image as input and passes it through a series of convolution and pooling layers followed finally by 3 fully connected layers.
It uses both the Content and Style representation to form the target image.

## Loss Functions
### **Content Loss**

A loss that calculates the difference between the content image and the target image representations. Aim is to minimize the content loss.

### **_L__content_ =  1⁄2 ∑ (Tc - Cc)2**

### **Gram Matrix**

To make sure that our target image have same content as our content image. We calculate the content loss that compares the content representation of 2 images. Same can be done to the style image, this can be calculated after looking at how similar features of a single layer are.
* Vectorize values in the last pooling layer (Flattening) **3D -> 2D**
* Multiply resultant 2D matrix to its transpose to get the gram matrix.

### **Style Loss**

To find the Style loss between the target and style image. We find the Mean Squared distance between the style and target image gram matrices.

### **_L__style_ =  a ∑i wi (Ts,i - Ss,i)2**

### **Total Loss**

Combining Content loss and Style loss will give total loss and then we use typical backpropagation and optimization to reduce this loss by iteratively changing the target image to match our desired content and style.

### **_L__total_** = **α** [_L__content_] + **β** [_L__style_] =  **α** [1⁄2 ∑ (Tc - Cc)2]  +  **β** [a ∑i wi (Ts,i - Ss,i)2]

**α** and **β**  are the amount or the ratio of content and style you want to add to the target image.

## Training Process
![Training Content Image with Style](https://github.com/AbhiSaphire/Style-Transfer-DNN/blob/master/Training.png)

## Results
### PS - Ran only 2000 iteration of updates on content image.
![Content vs Content with Poster style applied](https://github.com/AbhiSaphire/Style-Transfer-DNN/blob/master/ModiWithPaperFilter.png)
![Content vs Content with Paint style applied](https://github.com/AbhiSaphire/Style-Transfer-DNN/blob/master/ModiWithPaintFilter.png)

### **Cheers**

repository: AbhiSaphire/Style-Transfer-DNN

repo_name: AbhiSaphire/Style-Transfer-DNN


text:
# ** DEFINING GIT STATUS**

## The git status command displays the state of the working directory and the staging area. It lets you see which changes have been staged, which haven’t, and which files aren’t being tracked by Git. Status output does not show you any information regarding the committed project history. For this, you need to use `git log`.

# **USAGE**

## `git status`

## *List which files are staged, unstaged, and untracked.*

# Git Status when working tree is Clean

Before we make any new changes lets see the status of the Git repository in which we are working (First Project). (Refer Git Repository)

1. Open Git Bash

2. Navigate to the directory of the repository (First Project).

3. Type the following command git status and Press enter to execute the command.

![IMAGES](https://www.toolsqa.com/wp-content/gallery/git/git_status_execute.png)

### *As clearly visible, there is nothing to commit and the working tree is clean i.e. there are no untracked files.*

repository: ruchi-repo/project-xx

repo_name: ruchi-repo/project-xx


text:
## Demo

![alt text](https://github.com/caiovini/e-commerce-ipfs/blob/master/Demo.gif)

# e-commerce-ipfs
E-commerce developed using ipfs and orbit db to store user's data

This is a particular project using react, ipfs, orbit db, gun db and solidity. The idea is to develop a software completely descentralized where we can stabilish rules to sellers and buyers using smart contracts in the ehtereum network.

To run this project:

git clone https://github.com/caiovini/e-commerce-ipfs.git

"npm install" to install dependencies

"npm start" to start the project

Also run the server on: https://github.com/caiovini/orbitdb-server

Run an instance of go-ipfs: https://github.com/ipfs/go-ipfs using the command "ipfs daemon --enable-pubsub-experiment"

The name eAgora stands for electronic agora. The definition of agora is given by Samuel Edward Konkin III as:

"The goal of agorism is the agora. The society of the open marketplace as near to untainted by theft, assault, and fraud as can be humanly attained is as close to a free society as can be achieved. And a free society is the only one in which each and every one of us can satisfy his or her subjective values without crushing others' values by violence and coercion."

repository: caiovini/e-commerce-ipfs

repo_name: caiovini/e-commerce-ipfs


text:
# PrioTicket
[![Gem Version](https://badge.fury.io/rb/prioticket.svg)](https://badge.fury.io/rb/prioticket)
[![Dependency Status](https://gemnasium.com/henkm/prioticket.svg)](https://gemnasium.com/henkm/prioticket)
[![Code Climate](https://codeclimate.com/github/henkm/prioticket/badges/gpa.svg)](https://codeclimate.com/github/henkm/prioticket)

This gem works as a simple Ruby wrapper for the PrioTicket API. All the API functions are implemented.

Instead of working with JSON, you work with Ruby Classes and intuitive methods.

**This gem communicates with the API Version 2.4.**

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'prioticket'
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install prioticket

## Configuration

First, obtain an API key from PrioTicket. Set it up like this:
```ruby
PrioTicket::Config.api_key      = "MY-API-KEY"
PrioTicket::Config.environment  = "test"
```

To use this gem in a Rails project:
```ruby
# config/development.rb
config.prioticcket.api_key      = "MY-API-KEY"
config.prioticcket.environment  = "test"
```

## Usage
The available classes and methods are listed below. General rule of thumb: all the naming is 100% consistant with the official API Documentation. So use `PrioTicket::Booking.new(booking_name: 'John Doe', booking_email: 'john@example.net')` instead of using the more intuitive `PrioTicket::Booking.new(name: 'John Doe', email: 'john@example.com')`

**Important**: the `Reservation` and `Booking` classes will only create a new reservation/booking in memory, when initialized (e.g. `Reservation.new(...)`). To submit it to the server, call `save`.

### TicketList
To list the available tickets, call:
```ruby
@ticket_list = PrioTicket::TicketList.find(distributor_id: 1234, identifier: "my-unique-order-abc-123")
# Returns an object with a method `tickets`, which returns an array of tickets:
# => <PrioTicket::TicketList @tickets=[##<PrioTicket::Ticket @ticket_id=362, @ticket_title="100 Highlights  Cruise", @venue_name="Stromma Nederland", @txt_language="zh,ru,pt,nl,it,fr,de,es,en">, etc...]>
```

### TicketDetails
There are two ways to collect detailed information about a Ticket from the TicketList:

#### Find them using the `find` method

```ruby
@ticket_details = PrioTicket::TicketDetails.find(distributor_id: 1234, ticket_id: 123, identifier: "my-unique-order-abc-123")
# => <PrioTicket::TicketDetails @ticket_id=1234, @ticket_title="100 Highlights  Cruise", @short_description="The No.1 Amsterdam canal cruise", etc...>
```

#### Collect them via the parent object
```ruby
@ticket_list = PrioTicket::TicketList.find(distributor_id: 1234, identifier: "my-unique-order-abc-123")
@ticket_details = @ticket_list.first.ticket_details
# => <PrioTicket::TicketDetails @ticket_id=1234, @ticket_title="100 Highlights  Cruise", @short_description="The No.1 Amsterdam canal cruise", etc...>
```

So to get the tags from a certain TicketDetails, you can call:
```ruby
@ticket_list.first.ticket_details.tags
# => ["Students", "Wheelchair accessible"]
```
or:
```ruby
@ticket_list.first.ticket_details.company_opening_times.first.start_from
# => "09:00:00"

```

### Availabilities
The same goes for fetching availabilities:
```ruby
  @availabilities = PrioTicket::Availabilities.find(distributor_id: 1234, ticket_id: 123, identifier: "my-unique-order-abc-123", from_date: Time.now, until_date: Time.now+(60*60*24*7))
  # or:
  @availabilities = @ticket_details.availabilities(from_date: Time.now, until_date: Time.now+(60*60*24*7))
```

### Reservation
To reserve a date, use the `PrioTicket::Reservation` class:
```ruby
@reservation = PrioTicket::Reservation.new(
  identifier: "my-unique-order-abc-123",
  distributor_id: 1234,
  ticket_id: 123,
  from_date_time: @availabilities.first.from_date_time,
  to_date_time: @availabilities.first.to_date_time,
  booking_details: [{ticket_type: "ADULT", count: 1}],
  distributor_reference: "TEST_RESERVATION"
)
# at this point, the reservation is only made in memory, but not yet
# send to the PrioTicket server. To make in final, call `save`.

@reservation.save
# => #<PrioTicket::Reservation @identifier="test-1522067114", @distributor_id=1234, @ticket_id=123, @from_date_time="2018-03-26T23:00:00+02:00", @to_date_time="2018-03-26T23:59:00+02:00", @booking_details=[#<OpenStruct ticket_type="ADULT", count=1>], @distributor_reference="TEST_RESERVATION", @booking_status="Reserved", @reservation_reference="YYY2067115376XXX">

# Cancel this reservation:
@reservation.cancel
@reservation.booking_status #=> "Cancelled"
```

A direct way to cancel a reservation, is to call the class method `.cancel`:
```ruby
PrioTicket::Reservation.cancel(
  distributor_id: 1234,
  reservation_reference: "YYY2067115376XXX",
  distributor_reference: "TEST_RESERVATION",
  identifier: "my-unique-order-abc-123"
)
```

### Booking
To make a booking, please take note of the official API Documentation: for tickets of type_2 and type_3, a `from_date_time` and `to_date_time` must be present.

Example code in section below.

## Full example
All the steps are combined in the example below:
1. Setup the API credentials
2. Get a list of all the tickets/products
3. Find out details of a specific ticket
4. Get availability
5. Make a booking
6. Get status / cancel booking

```ruby

# step 1
# config/development.rb (in case of Ruby on Rails App)
config.prioticcket.api_key      = "MY-API-KEY"
config.prioticcket.environment  = "test"

# Code below goes in a controller or model, handling the application logic

# step 2
@ticket_list = PrioTicket::TicketList.find(distributor_id: 1234, identifier: "test-123")

# step 3
@ticket = @ticket_list.tickets.first.details
#=> <PrioTicket::TicketDetails> includes name, prices, etc.

# step 4
# method defaults to 3 weeks ahead, you can provice from_date_time and to_date_time
@available_times = @ticket.availabilities

# step 5 - book first available time
@booking = PrioTicket::Booking.new(
  identifier: "test-123",
  distributor_id: 1234,
  booking_type: {
    ticket_id: @ticket.ticket_id,
    booking_details: [{
      ticket_type: "ADULT",
      count: 2,
      extra_options: []
    }]
  },
  booking_name: "John Doe",
  booking_email<EMAIL_ADDRESS>  contact: {
    address: {
      street: "Amstel 1",
      postal_code: "1011 PN",
      city: "Amsterdam"
    },
    phonenumber: "0643210123"
  },
  notes: ["This is a test booking"],
  product_language: "en",
  distributor_reference: "ABC123456"
)

# the booking is now made in memory, but not yet final
@booking.confirmed?
# => false

@booking.save
# => <PrioTicket::Booking> object, with status and barcodes

@booking.confirmed?
# => true

@booking.cancel
@booking.confirmed?
# => false
@booking.canceled?
# => true

@booking.booking_reference # => 123ABC456XYZ

# another way to ask for the status of a booking:
@booking = PrioTicket::Booking.get_status(
  identifier: @booking.identifier,
  distributor_id: DIST_ID,
  booking_reference: "123ABC456XYZ",
  distributor_reference: "ABC123456
)
@booking.status # => "Cancelled"
```

## Contributing

Bug reports and pull requests are welcome on GitHub at https://github.com/henkm/prioticket.

## License

The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT). No rights can be derrived from using this library.

This gem is made with love by the smart people at [Eskes Media B.V.](https://www.eskesmedia.nl) and [DagjeWeg.NL Tickets](https://www.dagjewegtickets.nl)
PrioTicket is not involved with this project and has no affiliation with Eskes Media B.V.

repository: henkm/prioticket

repo_name: henkm/prioticket


text:
---
title: "porter mixins search"
slug: porter_mixins_search
url: /cli/porter_mixins_search/
---
## porter mixins search

Search available mixins

### Synopsis

Search available mixins. You can specify an optional mixin name query, where the results are filtered by mixins whose name contains the query term.

```
porter mixins search [QUERY] [flags]
```

### Examples

```
  porter mixin search
  porter mixin search helm
  porter mixin search -o json
```

### Options

```
  -h, --help            help for search
  -o, --output string   Output format, allowed values are: table, json, yaml (default "table")
```

### Options inherited from parent commands

```
      --debug           Enable debug logging
      --debug-plugins   Enable plugin debug logging
```

### SEE ALSO

* [porter mixins](/cli/porter_mixins/)	 - Mixin commands. Mixins assist with authoring bundles.

repository: simongdavies/porter

repo_name: simongdavies/porter


text:
# Project Title.
 * Awards.

* Awards is a django application that allows users to post their projects for others to rate and review

## Requirements
##### These are the requirements you need to get the project running locally on your machine:
  * Text Editor
  * Install python
  * Install and activate virtual
  * Setup Database
  * Install Django

## Installation Process
 * Download any text editor of your choice, either Sublime, Visual-Studio-Code or Atom.
 * Install your preferred version of python
 * ```sudo apt-get install python3.6```
 * ```python --version``` to confirm that python has been installed.
## Open the command-line and run the following command to open a directory:
  * ```cd your preferred directory``` => ```cd instagram```
## Git clone the project on your current directory by:
  * ```git clone https://github.com/tonyguthiga/reviews.git```.
## Move to your project directory:
 * ```cd reviews```.
## Open the project on your terminal:
  * ```atom . or code .``` , according to the type of your text editor.
## Install virtual environment using python:
  * ```python3.6 -m venv virtual```, check your project to confirm you have a folder called virtual,
  * then activate it by running ```source virtual/bin/activate```
## To install the packages in the ```requirements.txt file```,
  * ```pip install -r requirements.txt```  That will install all packages including Django.
## To open python shell:
  * ```python3.6``` ,
  * ```import django```
  * And lastly ```django.get_version()``` to see and confirm the version of django installed.
  * You can then ```ctrl z``` to get out of the shell,
## After ensuring you have all the above
  * ```python3 manage.py runserver``` to run the project.
  * Then click the local host link given to open the project on a browser ```http://<IP_ADDRESS>:8000/```.

## For more information read the following django and python documentation:
  * [DjangoDocumentation](https://docs.djangoproject.com/en/1.11/intro/install/)
  * [PythonDocumentation](https://www.python.org/doc/)

## User Stories
* As a user, I would like to view posted projects and their details.
* As a user, I would like to post a project to be rated/reviewed.
* As a user, I would like to rate/review other users' projects.
* As a user, I would like to search for projects.
* As a user, I would like to view projects overall score.
* As a user, I would like to view my profile page.

## Behavior Driven Development
* Given that a user sign-up with the correct details, and use those details to login successfully, then they should be able to access the application and it's features.
* Given that the user has uploaded a photo, then the application should display the photo uploaded.
* Given that a user has logged in, created a profile and posted a picture, then they  should be able
  to view their profile and all the photos they've posted.
* Given that a user has an account, then they should be able to rate and review other users projects.

## Technologies Used
* Python
* Django
* PostgreSQL
* HTML5
* Font Awesome
* Bootstrap 4

## License
MIT Copyright (c) 2020

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

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

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

## Author:

Antony Guthiga

## Contact Detail:

tonyguthiga93@gmail.com

repository: tonyguthiga/reviews

repo_name: tonyguthiga/reviews


text:
[![Build Status](https://travis-ci.org/tanakahisateru/oreore-waf-2017-spring.svg?branch=master)](https://travis-ci.org/tanakahisateru/oreore-waf-2017-spring)

# OREORE-WAF 20178 Springummer

This is experimental project using modern regular (2018 the last year of 5.6/7.0) PHP standards/technologies.

"OREORE" means personally designed and self maintained techs in Japanese web developers culture. In the past,
a certain number of PHP users had their own easy and fragile layers to avoid the difficulty of learning
mature framework APIs.

Though early PHP didn't have enough features to design good framework especially for not matured programmers.
But after 5.x to choose popular framework product is one of best practice for PHP. Furthermore PHP has been changed
by new PSRs:
[PSR-11](https://www.php-fig.org/psr/psr-11/),
[PSR-15](https://www.php-fig.org/psr/psr-15/),
[PSR-17](https://www.php-fig.org/psr/psr-17/)
which focus covering whole of application.

This "OREORE" framework describes how library interoperability realized by PSRs and suggests some ideas
to design framework free well connected components by small implementations.

## Installation / Usage

```bash
composer install
npm install
gulp
gulp vendor-debugbar
php -S <IP_ADDRESS>:8080 -t web
```

```bash
vendor/bin/codecept build
vendor/bin/codecept run
```

You can check css/js minification and revisioning:
```bash
gulp build
gulp dist
```

## Features

- HTTP Middleware ([PSR-7](http://www.php-fig.org/psr/psr-7/)/15/17) based design using
[Zend Diactoros](https://zendframework.github.io/zend-diactoros/) /
[Zend Stratigility](https://docs.zendframework.com/zend-stratigility/)
- [Aura.Di](https://github.com/auraphp/Aura.Di) (PSR-11) dependency injection container
- [Aura.Router](https://github.com/auraphp/Aura.Router) routing
- [Aura.Dispatcher](https://github.com/auraphp/Aura.Dispatcher) with controller dependency injection
- PHP script oriented config
- Inheritance free controllers
- View context to aggregate templates/routes/assets
- [Plate](http://platesphp.com/) template engine enhanced by Zend Escaper
- Minimal asset manager that works better with [Gulp](http://gulpjs.com/) tasks
- [Zend EventManager](https://zendframework.github.io/zend-eventmanager/) ([PSR-14](https://github.com/php-fig/fig-standards/blob/master/proposed/event-manager.md) like)
- [Monolog](https://seldaek.github.io/monolog/) [PSR-3](http://www.php-fig.org/psr/psr-3/) compatible logger
- [PHP Debug Bar](http://phpdebugbar.com/) to display logger result
- [Whoops](https://filp.github.io/whoops/) error page
- [Codeception](http://codeception.com/) functional test support for generic PSR-7/15 middleware app


text:
---
id: 125c990b-6fe7-4ada-a65f-44cbde8b33f0
title: Contribute
desc: ''
updated:<PHONE_NUMBER>150
created:<PHONE_NUMBER>150
nav_order: 9.5
---

# Contribute

## Documentation
If you would like to contribute to the docs, you can do so one of two ways.

1. Click `Edit this page on github` at the bottom left corner of every page. This is recommended way of making a change. The only pre-requisite is that you have a [github](https://github.com/) account.

2. For more involved changes, you can clone our github [repo](https://github.com/dendronhq/dendron-template) and opening `dendron.code-workspace` using VSCode.  [Dendron.so](https://www.dendron.so) is built from the contents of `vault/dendron.*`. Make a change in the corresponding file and send us a pull request to update the documentation. You can preview your changes using the `Dendron Markdown Enhanced` extension.

## Code

If you would like to contribute to the development of dendron, you can do so by following the [contribution guidelines](https://github.com/dendronhq/dendron/blob/master/docs/CONTRIBUTING.md) from the [dendron repo](https://github.com/dendronhq/dendron).

repository: eflinfoki/dendron-template

repo_name: eflinfoki/dendron-template


text:
# Number of Citations of Papers Awarded at CVPR Conference

The source code to reproduce the results of [this blog post](https://drsleep.github.io/solyanka/Number-of-Citations-of-Papers-Awarded-at-CVPR-Conferences/).

## Installation

```
Ubuntu
Python>=3.6
pip3
```

To install the required python packages, execute `pip3 install -r requirements.txt`

To reproduce the results, simply run `python main.py`

## Structure

### raw_data(.py)

Raw datasets for each award with the name of the awardees, the title of the publication and the year of the award. All the data are from the Computer Vision Foundation [page](https://www.thecvf.com/).

### parse_raw_data.py

Creates pandas.DataFrame objects from the raw data.

### get_citations_from_scholar.py

(Semi-)automatically parses data from Google Scholar via controlling your mouse and the keyboard. You have to configure it based on your setup.

### plot_data.py

Utilities to create the plots as in the blog post.

repository: Piaktipik/solyanka

repo_name: Piaktipik/solyanka


text:
# SetToGraphPaper
This repository holds the code for the paper: https://arxiv.org/abs/2002.08772.

## Data
Before running the code for the jets experiments, the data should be downloaded using the following commands:

```
cd SetToGraphPaper
python download_jets_data.py
```

This script will download all the data from Zenodo links.

## Code

### Prerequisites

You can use the following code to install a compatible environment (using anaconda), make sure to change the cuda toolkit version to the one that fits.
```
conda create -n s2g_env -c pytorch pytorch=1.5 cudatoolkit=10.2 torchvision
conda activate s2g_env
CUDA=cu102  # for cuda 10.2
pip install torch-scatter==latest+${CUDA} -f https://pytorch-geometric.com/whl/torch-1.5.0.html
pip install torch-sparse==latest+${CUDA} -f https://pytorch-geometric.com/whl/torch-1.5.0.html
pip install torch-cluster==latest+${CUDA} -f https://pytorch-geometric.com/whl/torch-1.5.0.html
pip install torch-spline-conv==latest+${CUDA} -f https://pytorch-geometric.com/whl/torch-1.5.0.html
pip install torch-geometric
conda install -c conda-forge -c anaconda tqdm easydict rdkit uproot
```

### Running the tests

The folder main_scripts contains scripts that run different experiments:
1. To run the main paticle-physics jets experiment with our chosen hyper-parameters, run the one of the following:
```
python main_scripts/main_jets.py --method=lin2  # for S2G
```
or
```
python main_scripts/main_jets.py --method=lin5  # for S2G+
```
or change `--method=...` with `--baseline=siam/siam3/gnn/mlp` for running a baseline.

2. To run the Delaunay triangulation with our hyper-parameters, run the main_delaunay.py script with the options `--many_sizes`/`--one_size` for n=50 or n\in{20,...,80}.
Example:
```
python main_scripts/main_delaunay.py --one_size --method=lin2
```

repository: hadarser/SetToGraphPaper

repo_name: hadarser/SetToGraphPaper


text:
# Changelog

All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.

## [2.0.0]

Initial release of the action. Branched from https://github.com/aws-actions/amazon-ecs-deploy-task-definition.git and modified to support pushing to ecs scheduled tasks instead of ECS services. Starting at 2.0.0 due to project being a fork and thus not being backwards compatible with old code.

### Features

- Adds in support for ECS scheduled tasks.
- Adds in tests to validate logic.
- Removes service deployment code.


text:
# Linting

Our recommended linter is [ESLint](http://eslint.org/).
This is what
our [Stickler configuration](https://github.com/dimagi/commcare-hq/blob/679d3ca7cf81d7808b6792a72046cedd891ed62f/.stickler.yml#L10)
uses.

## Running ESLint locally
The best time to find out about a code error (or stylistic faux pas) is when
you type it out.  For this reason, you should run a linter locally.

```shell
# Install it through npm:
$ npm install -g eslint

# Try it out locally if you like
$ eslint path/to/file.js
```

### PyCharm

PyCharm has different ways of setting this up depending on the version.

- [Instructions for 2016.1](https://www.jetbrains.com/help/pycharm/2016.1/using-javascript-code-quality-tools.html?origin=old_help#ESLint)
- [Instructions for 2017.3](https://www.jetbrains.com/help/pycharm/2017.3/eslint.html)

If you get errors you may need to [downgrade ESLint to version 5](https://intellij-support.jetbrains.com/hc/en-us/community/posts/360004195120-TypeError-this-cliEngine-is-not-a-constructor).
This appears to be an issue on all versions of PyCharm prior to 2019.1.3.

### Vim
#### NeoMake
[Install NeoMake](https://github.com/benekastah/neomake) if you haven't
already.
```
let g:neomake_javascript_enabled_makers = ['eslint']
```

#### Syntastic
[Install syntastic](https://github.com/scrooloose/syntastic) if you haven't
already.
```
let g:syntastic_javascript_checkers = ['eslint']
```

## Configuring our lint rules

The [.eslintrc.js](https://github.com/dimagi/commcare-hq/blob/master/.eslintrc.js) file in the root of the commcare-hq repository defines the rules to check.

While this configuration is fairly stable, see the [docs](https://eslint.org/docs/user-guide/configuring#configuring-rules) for help should you need to update it.

### Looking up rules
Let's say you ran eslint on this code
```javascript
var obj = {
    foo: 3,
    foo: 5
};
```
You'd probably get an error like:
> Duplicate key 'foo'. (no-dupe-keys)

The rule then is `no-dupe-keys`.  You can look it up on the [rules
page](http://eslint.org/docs/rules/) for a description.

  Sometimes it IS okay
to use `console.log`.  Here are a couple ways to say "yes, this IS okay".
```javascript
console.log('foo'); // eslint-disable-line no-console

// eslint-disable-next-line no-console
console.log('foo');
```
See the [docs](https://eslint.org/docs/user-guide/configuring#disabling-rules-with-inline-comments)
for more options to disable rules for on a case by case basis.

gha_language: Python