text:
## Heimdall
[![](https://img.shields.io/github/pipenv/locked/python-version/ciripel/heimdall)]() [![](https://img.shields.io/github/pipenv/locked/dependency-version/ciripel/heimdall/discord-py)]() [![](https://img.shields.io/github/pipenv/locked/dependency-version/ciripel/heimdall/pytz)]() [![](https://img.shields.io/github/pipenv/locked/dependency-version/ciripel/heimdall/gitpython)]() [![](https://img.shields.io/github/license/ciripel/heimdall)](LICENSE) [![](https://img.shields.io/github/issues/ciripel/heimdall)](https://github.com/ciripel/Heimdall/issues) [![](https://img.shields.io/github/issues-closed/ciripel/heimdall)](https://github.com/ciripel/Heimdall/issues)
### Discord bot for TENT https://tent.app/

v.1.6 - deployed 25.03.2020
- implemented !ban [substring] command that ban all users with the name containing the substring

v.1.5 - deployed 15.03.2020
- implemented !mn [address] command that can check information about a specific masternode

v.1.4 - deployed 16.02.2020
- implemented repo feeder into [TENT Development Progress](https://github.com/TENT/SnowgemDevelopmentProgress)

v.1.0 - deployed 23.01.2019
- initial version
- implemented these commands:
  help, netinfo, mninfo, hpow, xsgusd, mnrewards, roadmap, coininfo, about, members (CoreTeam only)

  NOTE: need to create a empty list file `[]` with name dev-diary.json in main folder if it does not exist. ;)

repository: ciripel/Heimdall

repo_name: ciripel/Heimdall


text:
# Tools

`knossos` has various continuous-integration (CI) tests in place to ensure code quality and correctness, including formatting. The following tools may make it easier to comply with these checks locally before checking in code and failing the various CI tests. They are not automatically integrated into the workflow.

## VSCode

`knossos` uses [black](https://github.com/psf/black) for formatting. Note we currently use the default black line length of `88`. You may find the following settings useful. To use, copy them into `.vscode/settings.json` (don't commit them, they are covered by .gitignored) or your user settings:

```json
    "python.formatting.provider": "black",
    "editor.formatOnSave": true,
```

## [Pre-commit](https://github.com/pre-commit)

Pre-commit is a package manager for various git hooks that process files and can help with consistency and correctness. It is configured in [.pre-commit-config.yaml](.pre-commit-config.yaml) . If any changes are made, you will need to re-stage the relevant files and try again.

Per-user, to setup, run

```bash
pip install --requirement .\requirements-dev.txt
pre-commit install
```

Usually pre-commit will only be run on staged files. The first run will take a bit of time, but subsequent runs should be relatively fast.

You can apply pre-commit and hooks to all files using

```bash
pre-commit run --all-files
```

repository: tomjaguarpaw/knossos-ksc

branch_name: refs/heads/master

extension: md

gha_license_id: NOASSERTION

license_type: permissive

repo_name: tomjaguarpaw/knossos-ksc


text:
# Sublime Text PHP Code Indenter in Allman Style

A [Sublime Text](http://www.sublimetext.com) plug-in to style PHP code
according to [Allman Coding Standards](http://en.wikipedia.org/wiki/Indent_style#Allman_style) (BSD Style).

## Install

- Use the sublime package manager and search for Allman PHP
- Or download the [zip](https://github.com/himred/Sublime-Allman-PHP/archive/master.zip) to your Sublime Text 2 or 3 `Packages` directory.

## Requirements
 - PHP must be installed on your computer and the php executable must be in your PATH.

## Usage

AllmanPHP can be accessed from:

- In the right mouse button contextual menu "**Format Allman Style**"
- `ctrl/cmd + shift + P` : ***Allman PHP***

## Credits

- Modified SublimePHPTidy by Jon LaBelle [jonlabelle/SublimePhpTidy](https://github.com/jonlabelle/SublimePhpTidy)
- PHP Tidy script by Magnus Rosenbaum<EMAIL_ADDRESS>- Original Sublime PHP Tidy [welovewordpress/SublimePhpTidy](https://github.com/welovewordpress/SublimePhpTidy)

## Author

Salim Gasmi<EMAIL_ADDRESS>

repository: himred/Sublime-Allman-PHP

repo_name: himred/Sublime-Allman-PHP


text:
---
layout: post
title: "Malpractice Imperfect"
date: 2015-06-08
categories:
- We Can't Have Nice Things
---

Aaron Carroll, writing for the New York Times's Upshot Blog, on some interesting aspects of [medical malpractice][1]. Studies and surveys have shown for decades that there are certain specific things some doctors do which gets them sued for malpractice. Carroll runs through the literature and, in a departure for "old media," actually links to the studies in question. Basically, doctors get sued for malpractice when they don't spend enough time talking to their patients, not when they practice medicine poorly.

This isn't new, we all learned that in law school, and I think we also learned that legal malpractice lawsuits happen the same way. Talk to your clients, make them feel like you're listening to them, and you'll do okay. No kidding, right?

Here's the great part:

> Physicians and patients don’t communicate well even about malpractice. A study published in 1989 surveyed patients who sued physicians as well as physicians who had or had not been sued. Almost all (97 percent) of the patients reported negligence as the reason for their malpractice action. Fewer, about half, of non-sued physicians thought negligence was the cause of malpractice suits in general.
>
> Only 10 percent of sued physicians, however, thought negligence was the reason for claims against them. While only a fifth of patients reported financial compensation as their motive for suing, more than 80 percent of all physicians thought this was the reason patients filed suits.

Virtually every patient who files a malpractice suit thinks they've been neglected. Doctors who haven't been sued think malpractice suits are caused by doctors' negligence half the time.  They think that medical malpractice suits are a shameless cash grab.

The fact that there's some cognitive dissonance at play here isn't surprising. It's the depths to which this misunderstanding goes: we're approaching questions of epistemological possibilities here. Is it possible for physicians and plaintiffs to understand one another? And, like, what if what I see when I'm looking at the color orange isn't what you see at all, man? *Whoa*.

Actually, the one thing that most everyone agrees on, whether they be plaintiff or defendant, is that communication is key to preventing these kinds of problems in the first place. Why is why, in one recent study about people visiting emergency rooms for relatively harmless chest pains:

> The median estimate of whether a patient might die at home of a heart attack was 80 percent in patients and 10 percent in physicians.

Whoops.

[1]:	http://mobile.nytimes.com/2015/06/02/upshot/to-be-sued-less-doctors-should-talk-to-patients-more.html

license: MIT

repository: dominicmauro/blogipsa

gha_language: SCSS

repo_name: dominicmauro/blogipsa


text:
1. Modifiers (private, public etc)
2. Property Types (Attributes and Methods)
3. Use cases (Read, write, call, define) and where
   1. because there's no universal agreement on the necessity of modifiers, I have to explicit define use cases first especially for some one coming from another language that also implements the class concept
   2. attributes
      1. read
         1. inside instance method
         2. inside class method
         3. outside class
      2. modify
         1. inside instance method
         2. inside class method
         3. outside class
      3. declare
   3. methods
      1. call
         1. inside another instance method
         2. inside another class method
         3. outside class
      2. define
   4. where
      1. inside instance method
      2. inside class method
      3. inside class
      4. outside class
4. Underscores
   1. leading single yes for private
   2. there are other uses of underscores but all ignored
   3. will not use leading dunder for private
5. Attributes
   1. private instance (not directly writable outside the class)
   2. public instance
   3. Class
6. Methods
   1. private instance
   2. public instance
   3. Class

repository: simkimsia/mbe-model-compiler-for-django

repo_name: simkimsia/mbe-model-compiler-for-django


text:
# Set up

Follow the instructions below to install, build, and run the
Project Hoverboard locally in less than 15 minutes.

## Install the Hoverboard and dependencies

1. [Fork repository](https://github.com/gdg-x/hoverboard/fork) and clone your fork locally
1. Install [Node.js (v16)](https://nodejs.org/en/download/)
1. Install project dependencies: `npm ci` (`yarn` should work but it's not officially supported)
1. Create [Firebase account](https://console.firebase.google.com) and login into [Firebase CLI](https://firebase.google.com/docs/cli/): `npx firebase login`
1. Update [Hoverboard config](/config) and [Resources](/data). More info can be found [here](01-configure-app.md)
1. Import initial data to the Firebase Database
   - Generate `serviceAccount.json` file
     - Go to [console.firebase.google.com](https://console.firebase.google.com) -> Project settings -> Service accounts
     - Ensure that **Node.js** is selected and press **Generate new private key**
     - Read the warning and press **Generate key**
     - Save the file as `serviceAccount.json` and to the root of your hoverboard directory (❗Do NOT commit this file to the public repository)
   - Enable Firestore in web console at [console.firebase.google.com](https://console.firebase.google.com) -> Database -> Cloud Firestore -> Create database. Select **locked mode** and press **Enable**
   - [Optional] You can edit `docs/default-firebase-data.json)` file using your own data
   - Select your Firebase project `npx firebase use <projectId>`
     - [Optional] If you need to clear out all of your data first, run `npx firebase firestore:delete --recursive --all-collections`
     - Run `npm run firestore:init`

## Directory structure

The diagram below is a brief summary of the directories within the project.

    /
    |---config/
    |---data/
    |---dist/
    |---docs/
    |---functions/
    |---images/
    |---scripts/
    |---node_modules/
    |---src/
    |   |---components/
    |   |---elements/
    |   |---mixins/
    |   |---pages/
    |

- `config/` folder for core project setup.
- `data/` folder with all data for the template including rest of config and resources for pages.
- `dist/` is the directory to deploy to production.
- `docs/` documentation.
- `functions/` directory with Firebase [cloud functions](https://firebase.google.com/docs/functions/) used for notifications, optimizations, saving data, etc.
- `images/` is for static images.
- `scripts/` contains scripts that helps user to work with the project and it's data ([docs](./firebase-utils.md)).
- `node_modules/` is the place of Node dependencies.
- `src/` is where you store all of your source code and do all of your development.
  - `components/` is where you keep your new LitElement custom elements.
  - `elements/` is where you keep your old Polymer custom elements.
  - `mixins/` is where you keep your shared component mixins.
  - `pages/` is where you keep your pages' description.

## Build and serve

1. Specify the Firebase project to use for development and deploy target
   - `npx firebase use <projectid>`.
1. Run locally
   - `npm start`
1. Deploy
   - `npm run deploy`

There are two CLI flags you can set when running npm scripts:

- `NODE_ENV`: Control if code should be optimized for a production deployment with minimization or for faster local development.
- `BUILD_ENV`: Which `config` JSON file should be used when building. This is where you set the Firebase project details.

The common npm scripts are:

- `npm start`: Start a local development server using the Firebase emulator with livereload.
- `npm run build`: Build a production version of the site to the `dist` directory.
- `npm run serve`: Build a production version of the site and serve it locally.
- `npm run deploy`: Build a production version of the site and deploy it to Firebase.

Below is the grid of the common npm script commands and their supported CLI flags.

|          | `NODE_ENV`    | `BUILD_ENV`                           |
| -------- | ------------- | ------------------------------------- |
| `start`  | `development` | `development`\|`production`\|`custom` |
| `build`  | `production`  | `development`\|`production`\|`custom` |
| `serve`  | `production`  | `development`\|`production`\|`custom` |
| `deploy` | `production`  | `development`\|`production`\|`custom` |

For example `npm start` only supports `NODE_ENV=development` and defaults to `BUILD_ENV=development` while `npm run build` only supports `NODE_ENV=production` and defaults to `BUILD_ENV=production`.

## Next steps

Now that your Hoverboard is up and running, learn how to
[configure the app](01-configure-app.md) for your needs, or how to [deploy the app to the web](04-deploy.md).

repository: gdg-x/hoverboard

branch_name: refs/heads/main

gha_language: TypeScript

repo_name: gdg-x/hoverboard


text:
# SQL API

SQL API is designed to be able to run queries on databases without any configuration by simple HTTP call. The request contains the DB credentials and the query as well.

**Warning!** Do not use it in production. SQL API is suitable for test environments. In particular for `integration tests`.

## Supported Databases

- MySQL
- MSSQL
- MongoDB

## Usage

Start the docker container named sqlapi by running the following command.

```bash
docker run --rm  --name sqlapi -p 8033:8033 techciceksepeti/sqlapi
```

**Example request:**

```bash
curl -X POST  http://localhost:8033/sql \
  -d '{
        "db": {
            "type": "mysql",
            "host": "hostname:3306",
            "name": "DBName",
            "user": "username",
            "password": "pass"
        },
        "query": "SELECT * from TableName LIMIT 1"
    }'
```

**Example Response:**

The response represents the rows returned from the database.

```json
[
  {
    "Id": 1,
    "Name": "Electronic",
    "Type": 2,
    "Sequence": 1
  }
]
```

**Example request for mongodb:**

```bash
curl -X POST  http://localhost:8033/sql \
  -d '{
        "db": {
            "type": "mongodb",
            "host": "localhost:27017",
            "name": "DBName",
            "user": "mongoadmin",
            "password": "secret"
        },
        "collection": "CollectionName",
        "query": "{\"_id\":\"609a80caa23379b236426ad2\"}"
    }'
````

## License

The SQL API is open-sourced software licensed under the MIT license.

repository: klckerim/sqlapi

repo_name: klckerim/sqlapi


text:
## Contributing

> To get started...

- 🍴 Fork this repo [here](https://github.com/fvcproductions/hire-me#fork-destination-box)
- 🔨 Hack away
- 👥 Add yourself as a contributor under credits
- 🔧 Make a pull request [here](https://github.com/fvcproductions/hire-me/compare)
- 🎉 Get your pull request approved - success!

Or just [create an issue](https://github.com/fvcproductions/hire-me/issues) - any little bit of help counts! 😊

repository: kanjamad/hire-me

gha_license_id: MIT

repo_name: kanjamad/hire-me


text:
# How to scale out a DolphinDB cluster

## 1. About DolphinDB Cluster

A DolphinDB cluster consists of 3 types of nodes: controller, agent and data node.
- A controller manages the metadata of a cluster and provides the web cluster management interface.
  A controller has the following 3 configuration files:
    - controller.cfg: the configuration parameters for the controller node, such as IP address, port number, the maximum number of connections, etc.
    - cluster.nodes: a list of nodes in the cluster. The controller node uses this file to get information of the cluster nodes.
    - cluster.cfg: individual configuration of each node in the cluster, such as parameter 'volumes' of a node.
- An agent is deployed on each physical machine and is responsible for starting and stopping local data nodes. The configuration file on the agent is:
    - agent.cfg: specifies properties relevant to the agent node, such as IP and port, the cluster's controller node, etc.
- Data dodes for computing, querying, and data storing.

Follow the following steps to add a new physical machine to a cluster:
- Deploy an agent node on the new server and configure the file agent.cfg
- Register information about the new agent node and new data nodes with the controller node
- Restart the controller and all data nodes

To expand the storage space of an existing data node, we can modify the node configuration file to add a path to parameter 'volumes'.

## 2. Add Data Nodes

In the example below, we will add a new physical server to a cluster and deploy a data node on it.

The cluster was deployed on the following 4 servers:

```
<IP_ADDRESS> : controller
<IP_ADDRESS> : datanode1
<IP_ADDRESS> : datanode2
<IP_ADDRESS> : datanode3
```

The cluster has the following configuration files:

controller.cfg
```
localSite=<IP_ADDRESS>:8990:ctl8990
```

cluster.nodes
```
localSite,mode
<IP_ADDRESS>:8701:agent1,agent
<IP_ADDRESS>:8701:agent2,agent
<IP_ADDRESS>:8701:agent3,agent
<IP_ADDRESS>:8801:node1,datanode
<IP_ADDRESS>:8802:node2,datanode
<IP_ADDRESS>:8803:node3,datanode
```

The command line to start the controller:
```
nohup ./dolphindb -console 0 -mode controller -script dolphindb.dos -config config/controller.cfg -logFile log/controller.log -nodesFile config/cluster.nodes &
```
The command line to start the agent:
```
./dolphindb -mode agent -home data -script dolphindb.dos -config config/agent.cfg -logFile log/agent.log
```

Create a partitioned database in the cluster:
```
data = table(1..1000 as id,rand(`A`B`C,1000) as name)
db = database("dfs://scaleout_test_db",RANGE,cutPoints(1..2000,10))
tb = db.createPartitionedTable(data,`scaleoutTB,`id)
tb.append!(data)
```
We can browse the data in the DFS Explorer of the cluster web interface.

![image](https://github.com/dolphindb/Tutorials_CN/blob/master/images/scaleout/scale_dfs_exp1.PNG?raw=true)

> * For more details about cluster configuration, please refer to [DolphinDB Cluster Deployment on Multiple Servers](https://github.com/dolphindb/Tutorials_CN/blob/master/multi_machine_cluster_deploy.md)

The IP address of the new machine:
```
<IP_ADDRESS>
```
The IP address, port number and the unique alias name of the data node in the cluster:
```
<IP_ADDRESS>:8804:datanode4
```

### 2.1 Configure the New Agent

Agent node is deployed in the directory `/home/<DolphinDBRoot>`. Copy the files in the directory on any server to the directory `/home/<DolphinDBRoot>` of the new machine, and modify /home/<DolphinDBRoot>/config/agent.cfg as follows:

```
//specify the IP address and port number of the new agent node
localSite=<IP_ADDRESS>:8701:agent4

//the controller node information
controllerSite=<IP_ADDRESS>:8990:ctl8990

Mode=agent
```

### 2.2 Configure Controller

Modify the file cluster.nodes to include the new agent node and data node:

```
localSite,mode
<IP_ADDRESS>:8701:agent1,agent
<IP_ADDRESS>:8701:agent2,agent
<IP_ADDRESS>:8701:agent3,agent
<IP_ADDRESS>:8801:node1,datanode
<IP_ADDRESS>:8802:node2,datanode
<IP_ADDRESS>:8803:node3,datanode

//new agent node and data node
<IP_ADDRESS>:8704:agent4,agent
<IP_ADDRESS>:8804:node4,datanode
```

#### 2.3 Restart the cluster

Restart the entire cluster, including the controller node and all data nodes.

- Close all data nodes on the web interface ```http://<IP_ADDRESS>:8990```.

 ![image](https://github.com/dolphindb/Tutorials_CN/blob/master/images/scaleout/controller_stopAll.PNG?raw=true)

- Execute ```pkill dolphindb``` on the server (<IP_ADDRESS>) to shut down the controller node.

- After waiting for about half a minute (for the port to be released), restart the controller.

- Back to the web interface, you can see that a new agent node has been added and is started, and all data nodes are started.

 ![image](https://github.com/dolphindb/Tutorials_CN/blob/master/images/scaleout/Controller_StartAll.PNG?raw=true)

By now we have successfully added a new server and a new data node to the cluster.

### 2.4 Verification

Let's verify that the new data node is enabled in the cluster by writing some data to the cluster.
```
Tb = database("dfs://scaleout_test_db").loadTable("scaleoutTB")
Tb.append!(table(1001..1500 as id,rand(`A`B`C,500) as name))
```
In the DFS Explorer, you should see that the data has been populated to the new data node.

![image](https://github.com/dolphindb/Tutorials_CN/blob/master/images/scaleout/scale_dfs_exp2.PNG?raw=true)

## 3. Add Hard Disks to a Data Node

The storage capacity of existing data nodes might become insufficient. The following example explains how to add a hard disk to node3.

The storage paths can be specified with the configuration parameter 'volumes'. The default storage path is `<HomeDir>/<Data Node Alias>/storage`.

> If you add a disk from the default path, you must explicitly set the original default path when specifying the parameter 'volumes'. Otherwise, the metadata will be lost in the default path.

The default value for parameter 'volumes' is as follows. You need to add it to the configuration file if it doesn't exist there.

cluster.cfg
```
node3.volumes=/home/server/data/node3/storage
```

To add the new disk path /dev/disk2/node3 to node3, just add the path to the line above after a comma.

cluster.cfg
```
node3.volumes=/home/server/data/node3/storage,/dev/disk2/node3
```

After modifying the configuration file, execute `loadClusterNodesConfigs()` on the controller to reload the configuration parameters. If the steps above are completed on the cluster management web interface, configuration parameters are automatically reloaded, and we don't need to execute `loadClusterNodesConfigs()`. After the configuration is completed, there is no need to restart the controller. Just restart node3 on the web interface so that the new configuration can take effect.

> If you would like the new storage to take effect immediately without restarting node3, you can execute `addVolumes("/dev/disk2/node3")` on node3. However, this will not be effective any more after the cluster restarts.

After the configuration is completed, execute the following script to write data to the cluster and check if data is written to the new disk.
```
tb = database("dfs://scaleout_test_db").loadTable("scaleoutTB")
tb.append!(table(1501..2000 as id,rand(`A`B`C,500) as name))
```
Data has been written to the disk:

![image](https://github.com/dolphindb/Tutorials_CN/blob/master/images/scaleout/3.PNG?raw=true)


text:
# mikayuu

mikayuu is header-only game engine for C++.

# Copyright
Copyright (C) 2016 akitsu sanae.
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE or copy at http://www.boost/org/LICENSE_1_0.txt)

mikayuu uses [glfw](http://www.glfw.org/), which is licensed by the zlib/libpng license.

> Copyright (c) 2002-2006 Marcus Geelnard
> Copyright (c) 2006-2016 Camilla Berglund<EMAIL_ADDRESS>
mikayuu uses [libpng](http://www.libpng.org/pub/png/libpng.html), which is licensed by the libpng license.

mikayuu uses [zlib](http://www.zlib.net/), which is licensed by the zlib license.

mikayuu uses [png++](http://www.nongnu.org/pngpp/), which is licensed by the BSD license.

> Copyright (c) 2007, 2008 Alexander Shulgin<EMAIL_ADDRESS>

repository: akitsu-sanae/mikayuu

repo_name: akitsu-sanae/mikayuu


text:
# Looks4

```text
material-4/Image/Looks4
```

```text
include('material-4/Image/Looks4')
```

| Illustration | Looks4 |
| :---: | :---: |
| ![illustration for Illustration](../../material-4/Image/Looks4.png) | ![illustration for Looks4](../../material-4/Image/Looks4.Local.png) |

## Looks4

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

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

' loads the package bootstrap
include('material-4/bootstrap')

' loads the Item which embeds the element Looks4
include('material-4/Image/Looks4')

' renders the element
Looks4('Looks4', 'Looks4', 'an optional tech label')
@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('material-4/bootstrap')

' loads the Item which embeds the element Looks4
include('material-4/Image/Looks4')

' renders the element
Looks4('Looks4', 'Looks4', 'an optional tech label')
@enduml
```

repository: VinayaSathyanarayana/plantuml-libs

repo_name: VinayaSathyanarayana/plantuml-libs


text:
**These steps are meant for those who want to run the main script of the game**

- [Download](https://www.python.org/downloads/) and [install](https://docs.python.org/3/using/index.html) latest python on your system
- Clone the repo in your desired location.

  Open terminal in a folder where you want the repo to be cloned
```bash
  git clone https://github.com/Suvradippaul/FLAPPING-PYBIRD.git
```
- Change the directory
```bash
  cd FLAPPING-PYBIRD
```
- Now the install the dependencies
```bash
  pip install -r requirements.txt
```
- Double click ```FLAPPING_BIRD.py```

repository: Suvradippaul/FLAPPING-PYBIRD

gha_language: HTML

repo_name: Suvradippaul/FLAPPING-PYBIRD


text:
# acci-cf
Cloudformation templates for Astrocompute CI

# Templates

## Bootstrap

The first template is used to bootstrap the Astrocompute CI environment. Go into the directory where the repository is cloned and run:

    aws cloudformation create-stack \
		--stack-name astrocompute-ci-bootstrap \
		--template-body file://.//cloudformation//bootstrap.template \
		--parameters ParameterKey=BucketName,ParameterValue="cookbook-bucket"

Make sure the bucketname is unique, see http://docs.aws.amazon.com/AmazonS3/latest/dev/BucketRestrictions.html

## Smtp

You need to setup your account to enable sending emails through the Amazon SES service. This has to be done manually in the AWS console. First go to the SES service and choose "Email Addresses". Then select the "Verify a new Email Address" option. Here you verify the email address that you want to use for the "ReplyToAddress" parameter and the "recipients" value in the secrets.json file.

The next step is to get the credentials for sending email through the smtp service. Go to the SMTP settings option and select "Create My SMTP Credentials". There you will create a new IAM user. There you get the opportunity to get the required credentials. Add these to the secrets.json file.

## opsworks-jenkins

This template is used to start an opsworks stack for setting up a jenkins server and some jenkins slaves:

    aws cloudformation create-stack --stack-name opsworks-jenkins \
		--template-body file://.//cloudformation//opsworks-jenkins-stack.template \
		--parameters ParameterKey=BucketName,ParameterValue="cookbook-bucket" \
		    ParameterKey=DomainName,ParameterValue="example.com" \
		    ParameterKey=ServerAlias,ParameterValue="jenkins" \
<EMAIL_ADDRESS>\
			ParameterKey=KeyName,ParameterValue="aws_user_key" \
			ParameterKey="CookBookFile",ParameterValue="cookbooks.tar.gz" \
		    ParameterKey=VpcId,ParameterValue="vpc-abcd1234"

The "BucketName" parameter points to the bucket that is created with the "bootstrap" template. The "DomainName" parameter is used for setting up the default suffix setting of the jenkins mailer plugin and CNAME record of the jenkins server. This must be a domainname that you control. The "ReplyToAddress" is the email address that is used to configure the reply-to setting in the jenkins mailer plugin.

The "Keyname" parameter is the name of a ssh keypair, used to login to the created instances. The "CookBookFile" parameter is the name of the file of the custom Chef cookbook, used to configure the stacks instances. This tarball should be upload to the S3 bucket before creating the stack. The "ServerAlias" parameter is the cname for the ELB instance.

The "VpcId" parameter is the id of the default vpc. You can find the id using the following command:

	aws ec2 describe-vpcs --query 'Vpcs[?IsDefault].[VpcId]' --output text

# Development

You can test the templates before using them by the command:

	aws cloudformation validate-template \
		--template-body file://.//cloudformation//bootstrap.template

This will return a json document if the template is correct.

## Chef cookbook

After a change in the custom cookbook of the stack, the cookbook should be packaged using the "berks" command and upload to the S3 bucket. After that, the new cookbook can be uploaded to the instances, using the following command:

	aws --region us-east-1 opsworks create-deployment \
	    --stack-id $(aws opsworks --region us-east-1 describe-stacks \
	        --query 'Stacks[?Name==`JenkinsStack`].[StackId]' --output text) \
	    --command "{\"Name\":\"update_custom_cookbooks\"}"

When the deployment is finished, execute the custom recipies using the following command:

	aws --region us-east-1 opsworks create-deployment \
		--stack-id $(aws opsworks --region us-east-1 describe-stacks \
			--query 'Stacks[?Name==`JenkinsStack`].[StackId]' --output text) \
		--command "{\"Name\":\"configure\"}"

# Cleanup

You can remove the stacks with the following commands:

	aws cloudformation delete-stack --stack-name opsworks-jenkins
	aws cloudformation delete-stack --stack-name astrocompute-ci-bootstrap

This removes all created resources from your account

repository: arjenderijke/acci-cf

repo_name: arjenderijke/acci-cf


text:
# Pandora 3.0 - Widgets

[![License: MIT](https://img.shields.io/badge/License-MIT-steelblue.svg)](https://opensource.org/licenses/MIT)

Widgets repository for [Pandora 3](https://github.com/PandoraTeam/pandora-3.0-core "Pandora 3 core repository") framework. Contains only widgets provided by default for easier install. Other widgets can be installed separately.


text:
# D-25 (Android Application)
The latest news from D-25 on your Android Phone!
http://d-25.net

### Project Started
I'm excited to start this project, side by side with the Alessio Giacobbe's Windows Phone project. Check it out: https://github.com/AlessioGiacobbe/D-25FeedReader .

### To Do List
Well, this is basically a feed reader. Let's make a To Do list anyway.
- [ ] Get the Feed list (I think this is important.)
- [ ] Share function!
- [ ] Notification about new post!

### Some useless F.A.Q.
##### What language is your Website?
Italian. We can't translate our website in English or another language.
##### Where it will be released?
It will be published with our not-dead-yet Google Play Store account.
##### When will it be released?
We have absolutely no idea :wink:


text:
---
title: Configure and connect to your VPN
menu:
  tutorials:
    weight: 10

---
Do you require a VPN connection for your build, to be able to connect to your server,
either to `git clone` your repository or to access a private API?
If yes, then this tutorial is for you!

## Technical infos

Connecting to a VPN, in short, works like this:

1. the build starts
1. you install & configure the VPN components you need
1. you start the VPN
1. you proceed with the build

Obviously, if you require a VPN connection in order to access your code repository,
you have to connect to the VPN __before__ the `Git Clone` step, but in general
you can configure & connect to the VPN anywhere in your Workflow, __before__ you'd use the
connection.

_You can choose other VPN tools, not just the one shown here ([strongswan](https://www.strongswan.org)),
this is just one example setup which works on [bitrise.io](https://www.bitrise.io)._

__One important note__: when you choose your VPN tool and do the setup/configuration,
you have to be careful to __not to restart / abort__ existing SSH sessions!
The [bitrise.io](https://www.bitrise.io) workers will abort the build
if the SSH connection between the build's Control/Master machine and
the Build virtual machine terminates!

## Example

This is an example script which you can either save into your repository and run
it from there, or just copy paste its content into a `Script Step` in your `bitrise`
configuration (`bitrise.yml` / Workflow).

```bash
#!/usr/bin/env bash
set -e

echo "WAN IP"
# This prints the servers Internet IP adress to the log, useful for debugging
curl http://httpbin.org/ip

case "$OSTYPE" in
  linux*)
    echo "Configuring for Linux"

    # Variables
    etc_dir=/etc
    etc_sudo='sudo' # Sudo is needed for Linux Strongswan configuration

    # Install strongswan
    echo "Installing Strongswan..."
    sudo apt-get install -y strongswan

    ;;
  darwin*)
    echo "Configuring for Mac OS"

    # Variables
    etc_dir=/usr/local/etc
    etc_sudo='' # Sudo is NOT needed for Mac OS Strongswan configuration

    # Install Strongswan using homebrew
    echo "Installing OpenSSL..."
    # Manually install OpenSSL first to save time, since installing Strongswan directly compiles OpenSSL from source instead
    brew install openssl
    echo "Installing Strongswan..."
    brew install strongswan

    ;;
  *)
    echo "Unknown operative system: $OSTYPE, exiting"
    exit 1
    ;;
esac

# Method for rendering a template string file (when run, returns the input string with $VARIABLES replaced from env)
render_template() {
  eval "echo \"$(cat $1)\""
}

# Create a temporary directory to hold files
temp_dir=/tmp/vpn-config
mkdir $temp_dir

# IPsec config file, see examples at https://wiki.strongswan.org/projects/strongswan/wiki/IKEv1Examples and https://wiki.strongswan.org/projects/strongswan/wiki/IKEv2Examples
echo "Downloading ipsec.conf..."
wget https://www.example.com/ipsec.conf.template -O $temp_dir/ipsec.conf.template
# IPsec credentials file, see documentation at https://wiki.strongswan.org/projects/strongswan/wiki/IpsecSecrets
echo "Downloading ipsec.secrets..."
wget https://www.example.com/ipsec.secrets.template -O $temp_dir/ipsec.secrets.template
# In some cases you might need to download the certificate, or certificate chain, of your other VPN endpoint
echo "Downloading server.crt..."
wget https://www.example.com/server.crt -O $temp_dir/server.crt

echo "Rendering config templates"
render_template $temp_dir/ipsec.conf.template > $temp_dir/ipsec.conf
render_template $temp_dir/ipsec.secrets.template > $temp_dir/ipsec.secrets

echo "Installing configuration"
$etc_sudo cp $temp_dir/ipsec.conf $etc_dir/ipsec.conf
$etc_sudo cp $temp_dir/ipsec.secrets $etc_dir/ipsec.secrets
$etc_sudo cp $temp_dir/server.crt $etc_dir/ipsec.d/ocspcerts/server.crt

# Start the ipsec service
echo "Starting ipsec"
sudo ipsec start

# We're sleeping between commands, mostly since Mac OS seems to have some problems otherwise
sleep 1

# Output some helpful status to the log
echo "Status ipsec"
sudo ipsec statusall

sleep 1

# Switch out myconnection with the name of your connection in ipsec.conf
echo "Initiating VPN connection"
sudo ipsec up myconnection

sleep 1

case "$OSTYPE" in
  linux*)
    ;;
  darwin*)
    # In Mac OS El Capitan, the `sudo ipsec up` command consistently fails the first time, but succeeds after a restart of the ipsec service
    echo "Restarting ipsec"
    sudo ipsec restart

    sleep 1

    echo "Initiating VPN connection"
    sudo ipsec up myconnection

    sleep 1

    # This step might apply if you are routing all traffic trough the IPsec connection (that is, if your remote IP range is <IP_ADDRESS>/0)
    # Mac OS El Capitan seems to have problems getting the DNS configuration from the Strongswan interface. Also IPv6 sometimes causes issues. So we're manually turning off IPv6 and forcing a new DNS configuration.
    echo "Disabling IPv6 and forcing DNS settings"
    # Fetch main interface
    main_interface=$(networksetup -listnetworkserviceorder | awk -F'\\) ' '/\(1\)/ {print $2}')
    # Completely disable IPv6
    sudo networksetup -setv6off "$main_interface"
    # Switch <IP_ADDRESS> with your DNS server
    sudo networksetup -setdnsservers "$main_interface" <IP_ADDRESS>
    ;;
  *) ;;
esac

# Your VPN connection should be up and running. Any following steps of your Bitrise workflow can access devices over your VPN connection 🎉

```

repository: kubode/devcenter

repo_name: kubode/devcenter


text:
# Strap - SRP6/6a (Secure Remote Password) for Elixir

This is a simple module that helps you implement the Secure Remote Password
(SRP) protocol in Elixir applications. For more information about SRP, see
the [design documents](http://srp.stanford.edu/design.html) and
[RFC5054](https://tools.ietf.org/html/rfc5054).

[![Build Status](https://travis-ci.org/twooster/strap.svg?branch=master)](https://travis-ci.org/twooster/strap)
[![Hex.pm Version](http://img.shields.io/hexpm/v/strap.svg?style=flat)](https://hex.pm/packages/strap)

## Installation

This package can be installed by adding `strap` to your list of dependencies in
`mix.exs`:

```elixir
def deps do
  [
    {:strap, "~> 0.1.1"}
  ]
end
```

If you're running inside of a Phoenix application, you may need to ensure the
Erlang crypto application is loaded.

```elixir
def application do
  [
    extra_applications: [
      :logger,
      :crypto
    ]
  ]
end
```

## Documentation

The HexDocs.pm documentation is available [here](https://hexdocs.pm/strap).

## SRP Flow

A typical SRP request/response flow looks like this:

1. Client gets username/password from user

2. Client -> Server: Client sends the username to the server.

3. Server looks up the user's information, from a database for example.
   This information would be the prime, generator, salt, and so-called verifier
   value for this user. Optionally, if the server doesn't know this user, it
   may return/calculate fake values to obscure the user's lack-of-presence.

4. Server generates a public value, based on the prime, generator, verifier,
   and an ephemeral randomly-generated private value only it knows.

5. Server -> Client: Server sends the prime, generator, salt, and
   public value back to the client.

6. Client generates a public value, based on the prime, generator, and
   an ephemeral randomly-generated private value only it knows.

7. Client -> Server: Client sends its public value to the server.

8. Server generates a pre-shared master key based upon the information it has.

9. Client generates a pre-shared master key based upon the information it has.

The server and client should, at this point, verify that their pre-shared master
keys match. For example, the client could send a `HMAC(key, server-public-key)`
to the server, and the server could send `HMAC(key, client-public-key)` back
to the client.

Altenatively, if the preshared key will be utilized for further encrypted
communication, not just authentication, the server and the client can simply
exchange encrypted messages using an agreed-upon cipher (e.g. AES-256). A
failure to decrypt messages indicates a lack of knowledge of the preshared key.

## Usage

This library helps with steps 4, 6, 8, and 9, above. An example flow might look
like:

```elixir
# Client

username = get_username()
private_client_password = get_password()

# Server

# Fetch verifier and salt from database
{salt, private_server_verifier} = get_salt_and_verifier(username)
# Use "known-good" prime/generator; could also be stored in database
{prime, generator} = Strap.prime_group(2048)

server =
  Strap.protocol(:srp6a, prime, generator)
  |> Strap.server(verifier)

server_public_value = Strap.public_value(server)

# Client

client =
  Strap.protocol(:srp6a, prime, generator)
  |> Strap.client(username, private_client_password, salt)

client_public_vlaue = Strap.public_value(client)

# Server

{:ok, private_server_session_key} =
  Strap.session_key(server, client_public_value)

# Client

{:ok, private_client_session_key} =
  Strap.session_key(client, server_public_value)

# At this point, the following should be true:

^private_server_session_key = private_client_session_key
```

repository: hoffi/strap

repo_name: hoffi/strap


text:
![Roc Logo](/roc-logo.png?raw=true "Roc Logo")

roc is a modern [Finagle][finagle] [Postgresql][postgresql] [Client][finagle-client]. What's modern? A Client relying on a [6.x +][finagle-changelog] version of Finagle.

roc is currently under heavy development and is not being published with a current version of `0.0.1-ALPHA`.
If you need a real driver right now you should absolutely use [finagle-postgres][finagle-postgresql-existing].

## Badges
[![PyPI](https://img.shields.io/pypi/l/Django.svg?style=plastic)]()
[![Circle CI](https://circleci.com/gh/penland365/roc/tree/master.svg?style=svg&circle-token=07305c9575ac3fcf0ab5bade8ae2f29921ac04c9)](https://circleci.com/gh/penland365/roc/tree/master)
[![codecov.io](https://codecov.io/github/penland365/roc/coverage.svg?branch=master)](https://codecov.io/github/penland365/roc?branch=master)

## tl;dr
roc is not being published yet. You'll have to clone/fork this repository, then build locally.

Once built, open `sbt console` and insert the following
```scala
scala > :paste
import com.twitter.util.Await
import roc.Postgresql
import roc.postgresql.{Request, Row}

val client = Postgresql.client
  .withUserAndPasswd("username", "password")
  .withDatabase("database")
  .newRichClient("inet!localhost:5432")
val req = new Request("SELECT * FROM STATES;")
val result = Await.result(client.query(req))
```
A result contains two types, a list of columns detailing information about
the result, and a list of rows returned from the database.
```scala
scala> result.columns

res1: List[com.github.finagle.roc.postgresql.Column] =
  List(Column(name='id, columnType=Int4, formatCode=Text),
   Column(name='name, columnType=VarChar, formatCode=Text), Column(name='abbrv, columnType=VarChar, formatCode=Text), Column(name='last_modified_at, columnType=TimestampWithTimezone, formatCode=Text),
   Column(name='inserted_at, columnType=TimestampWithTimezone, formatCode=Text)
  )

scala> :paste

val display = (r: Row) => {
  val id = r.get[Int]('id)
  val name = r.get[String]('name)
  val abbrv = r.get[String]('abbrv)
  val insertedAt = r.get[String]('inserted_at)
  val lastModifiedAt = r.get[String]('last_modified_at)
  println(s"Row $id, $name, $abbrv, $insertedAt, $lastModifiedAt")
}
// Exiting paste mode, now interpreting.

display: com.github.finagle.roc.postgresql.Row => Unit = <function1>

scala> result.rows.map(display(_))
Row 1, North Dakota, ND, 2016-02-18 09:50:55.445246-06, 2016-02-18 09:50:55.445246-06
res4: List[Unit] = List(())
```
At the moment, we can only return `Ints` and `Strings` (I told you it was `ALPHA`).
The good news is that most `Postgresql` columns can be read as strings first, then transformed into the appropriate type
 ( see the handling of Timestamps With TimeZone above).

## Motivation
Why create your own when there is an existing implementation? Two reasons

1. The current [finagle-postgres][finagle-postgresql-existing] was developed pre [Finagle 6.x][finagle-changelog] and does not use modern finagle abstractions. These are core enough to require what amounts to a complete rewrite of the driver.
2. The current project lacks a true owner - Twitter decided to give the Open Source team a [long vacation][twitter-long-vacation] last fall, and since then only a handful of projects are being actively managed.

It is absolutely the goal of this project to become the reference implementation, and hopefully be moved into the [Finagle ecosystem][finagle-ecosystem].

## What's in a name?
roc (*Rokh* or *Rukh*) is named after the Persian mythological bird of prey [Roc][roc-wikipedia],
 which was based in part on the now extinct [elephant bird][elephant-bird-wikipedia]. Yes, that means we've hit the rare 4 point play with the name

 Goal                             |Status
 :-------------------------------:|:----:
 short name                      |✔
 obligatory mythological reference|✔
 bird reference for Twitter       |✔
 elephant reference for Postgresql|✔

 High fives for everyone!
 ![Teenage Mutant Ninja Turtles High Fives](http://i.giphy.com/10LNj580n9OmiI.gif)

## Contributors and Participation

roc is currently maintained by [Jeffrey Davis][jeff-davis].

The roc project supports the [Typelevel][typelevel] [code of conduct][code-of-conduct] and wants
all of its channels (GitHub, etc.) to be welcoming environments for everyone.

## License

Licensed under the **[BSD-3-Clause](https://opensource.org/licenses/BSD-3-Clause)**
(Revised BSD Liscense); you may not use this software except in compliance with the License.

repository: gitter-badger/roc

repo_name: gitter-badger/roc


text:
Application Settings
====================

To be able to run this Functions application locally, you need to have a `local.settings.json` in the same directory with this documentation. The contents of that file should be:

``` JSON
{
  "IsEncrypted": false,
  "Values": {
    "FUNCTIONS_WORKER_RUNTIME": "dotnet",
    "AzureWebJobsStorage": "UseDevelopmentStorage=true",

    "SendGrid:ApiKey": string,
    "SendGrid:DefaultSender:Address": string,
    "SendGrid:DefaultSender:Name": string
  }
}
```

Settings
--------
The settings in the sample configuration above are:

- `SendGrid:ApiKey`: Required. Your SendGrid API key.
- `SendGrid:DefaultSender:Address`: Required. The e-mail address to use as sender by default, if no other address is specified when sending.
- `SendGrid:DefaultSender:Name`: Optional. The display name of the default sender.

Configuration in Azure
----------------------
To configure your functions applicaiton in Azure, you use the same key-value pairs as above.

repository: Mattegol/SendGrid-with-Azure-Functions

repo_name: Mattegol/SendGrid-with-Azure-Functions


text:
# break-time

[![Actions Status](https://github.com/cdepillabout/break-time/workflows/CI/badge.svg)](https://github.com/cdepillabout/break-time/actions)
[![crates.io](https://img.shields.io/crates/v/break-time.svg)](https://crates.io/crates/break-time)
[![dependency status](https://deps.rs/repo/github/cdepillabout/break-time/status.svg)](https://deps.rs/repo/github/cdepillabout/break-time)
![MIT license](https://img.shields.io/badge/license-MIT-blue.svg)

break-time is an application that forces you to take breaks while working at
your computer.  This is convenient for people that want to avoid sitting for
too long, or staring at the computer screen for too long.

The main feature of break-time is that there is no easy way to end a break
early.  Once a break starts, you are forced to stop using your computer.
However, there are plugins provided to avoid breaks at inconvenient times.  For
instance, there is a plugin to avoid having a break occur during a time when
you have an event on your Google Calendar, as well as a plugin to avoid a break
when you are on a video chat in Google Meet, Zoom, etc.

break-time currently only runs on Linux with X11.  However, PRs are welcome
adding support for other platforms and window systems.

## Installing

break-time requires a few system libraries to be available.  On Debian/Ubuntu systems, these can be installed with the following command:

```console
$ sudo apt-get install libgtk-3-dev libxcb-screensaver0-dev
```

After this, you can install break-time with
[`cargo`](https://doc.rust-lang.org/cargo/):

```console
$ cargo install break-time
```

## Usage

Once break-time is installed, I suggest running it once so that it creates a
configuration file.  Immediately kill it with Ctrl-C after
running it.

```console
$ break-time
^C
```

break-time should create a configuration file in
`~/.config/break-time/config.toml`.  Open up this configuration file in a text
editor to see what options are available.  If the explanations for any options
are not understandable, please open an issue.

The most interesting option will probably be `accounts` (or
`plugin.google_calendar.accounts`).  This is described in the next section.

After you have configured break-time, run it again.

```console
$ break-time
```

break-time will countdown until it is time for the next break.

break-time will create a systray icon.  If you mouse over it, it will tell you
how many minutes are left until your next break.  If you right click on the
systray icon, you can pause and resume the break countdown timer.

When it is time for your next break, break-time will pop up a screen telling
you to take a break.  You won't be able to close this screen until either the
break-time is over, or you press the spacebar 400 times.

### Plugins

break-time has plugins that are used to prevent a break from occurring.  Right
before a break is about to occur, break-time queries all the plugins and asks
if it is really okay to start a break.  This section explains how the plugins
work and how to configure them.

#### X Window Titles (Video Chat)

The X Window Title plugin checks whether or not there is an X Window with a
given name and title.

This is convenient to stop a break from occurring when you're in a video chat.

Currently, this plugin only checks for a few specific window names and titles.
You can see what window names and titles are checked for in
[this function](https://github.com/cdepillabout/break-time/blob/master/src/scheduler/plugins/window_titles.rs#L159-L193).

If you want additional applications to be supported, please open an
issue or send a PR modifying this function.

One way to check if this plugin is working is start break-time with a short
break interval, and then open https://meet.google.com/ in Firefox or Chromium.
break-time should not start a break while https://meet.google.com/ is open (and
the currently focused tab).

#### Google Calendar

The Google Calendar plugin checks whether or not there is an event on your
Google Calendar currently occurring.  If there is an event, the plugin stops
break-time from starting a break.

This is convenient to stop a break from happening when you're in a meeting at
work.

This plugin has a feature where if your Google Calendar event has a description
with the magic string `ignore break-time`, break-time will ignore it when
considering whether or not to start a break.

This plugin requires some configuration before it can be used.  First, you must
add your Gmail address to the break-time configuration file,
`~/.config/break-time/config.toml`.  The `accounts` (or
`plugin.google_calendar.accounts`) field should be set to a list of your Gmail
addresses.  I suggest only adding one at a time.

If your Gmail address is<EMAIL_ADDRESS>the configuration file will look
like the following:

```toml
[plugin.google_calendar]
accounts = [<EMAIL_ADDRESS>]
```

After adding this, restart break-time.  break-time should output a message like
the following:

```console
$ break-time
Please direct your browser to https://accounts.google.com/o/oauth2/auth... and follow the instructions displayed there.
```

Make sure you are signed in to<EMAIL_ADDRESS>in your browser (and not
another email address). Follow the link.  You should be presented with a
"Choose an account" page (as long as you have multiple Gmail accounts).  Make
sure you choose<EMAIL_ADDRESS>
Next, you'll be presented with a warning that the break-time app is not
verified.  Click the "Advanced" link, and then "Go to Break Time (unsafe)".

(This is currently necessary because I haven't completed the verification
request from Google for use of the Google Calendar API.  See issue
[#11](https://github.com/cdepillabout/break-time/issues/11) for slightly more
information.)

The next screen will ask you to grant break-time the following two permissions:

-   View events on all your calendars

    This allows break-time to check the start and end times of the events on
    your calendar.

-   View your calendars

    This allows break-time to determine what calendars you have, in order to
    determine where to check for events.

Once you grant break-time these permissions, break-time will save an OAuth
token to disk in `~/.cache/break-time/google-calendar/`.  This will allow
break-time to continue checking your Google Calendar without having to go
through this authorization step again in the future.

Note that break-time doesn't store your calendar data on disk, and it
definitely doesn't transmit it over the network after receiving it from the
Google Calendar API.  If you're worried about using this plugin, I'd recommend
reading the source code of the
[`google_calendar.rs`](https://github.com/cdepillabout/break-time/blob/master/src/scheduler/plugins/google_calendar.rs).
The only security concern is that break-time stores an OAuth token to disk so
that it can re-use it next time you start break-time.

If you want to use break-time with multiple Google Calendar accounts, you can
add multiple addresses to `plugin.google_calendar.accounts`.  Although, I suggest
only adding an account and doing authorization one at a time.

One way to check if this plugin is working is to set a short break interval,
and create an event on your calendar.  break-time should not start a break
while an event is taking place.

## Why

I noticed I was sitting in front of my computer for excessively long periods of
time.  I thought this was starting to lead to neck and shoulder pain, so I
wanted to find a way to force myself to take more breaks.

I tried a couple solutions, including a manual kitchen timer, timers on my
phone, applications like [Stretchly](https://hovancik.net/stretchly/), etc.
However, I've never found anything that really worked well.

I have three main problems with other solutions:

-   It is too easy to ignore the breaks.  When using a timer on my phone, I
	would often turn off the alarm and continue working.  When using Stretchly,
    I would often exit out of it whenever a break started.

    break-time fixes this by making it really hard to skip breaks.  Once a
    break starts, you're forced to step away from your computer.

-   Breaks occur at inconvenient times.  You never want a break to occur when
    you're doing something important, like in a meeting or in a video chat.

    break-time fixes this by having plugins to detect when you're in a meeting
    or in a video chat.

-   There is no warning that a break is coming.  With other solutions, it is
    frustrating when a break suddenly occurs in the middle of your work.

    break-time fixes this by having a countdown timer in the systray icon.
    You get a five-minute heads-up to wrap up any code you're writing,
    messages you're writing on Slack, documentation you're reading, etc.

break-time is one of the first non-trivial Rust programs I've created,
currently at around 2,500 lines (including whitespace and comments).

The main difficulty in writing break-time was trying to find a good abstraction
to deal with all the concurrent code.  In the end, I don't feel like I was able
to do this, but I created
[an issue](https://github.com/cdepillabout/break-time/issues/5) to think of how
to improve this.

## Contributions

Feel free to open an issue or PR for any
bugs, problems, suggestions, or improvements.

repository: cdepillabout/break-time

gha_language: Rust

repo_name: cdepillabout/break-time


text:
boids.js
========

This library allows you to simulate bird flock and fish school. This computer model of coordinated animal motion was
designed by [Craig Reynolds](http://www.red3d.com/cwr/boids/) in 1986. This model consists of three simple rules
which are separation, alignment and cohesion.

<img src="https://cloud.githubusercontent.com/assets/678921/6096668/0ae60406-afe2-11e4-95e9-dc4d1febc115.png" width="100%">
## Usage

Here is a very basic example.

```html
<script src="boids.js"></script>
<script>

window.onload = function() {

  var v = new boids.SteeredVehicle( -200, 0, 0 );
  var target = new boids.Vector3( 200, 0, 0 );

  function animate() {

    setTimeout(animate, 1000 / 30);
    update();
  }

  function update() {

    v.seek(target);
    v.update();
    console.log(v.position.x, v.position.y, v.position.z);
  }

  animate();
}

</script>
```

## License

Copyright (c) 2012-2015 Satoshi Okami. See the LICENSE file for license rights and limitations (MIT).


text:
---
layout: page
title: About Xu Hui
---

My name is Zhou Xuhui, sometimes I am called Joe(or Joe Zhou). I live in the Zhuhai City. When I am not working I typically do some DIY for fun, have fun by taking photos, enjoy the time with my family..

---

```
in Chinese and not updated
```

## 兴趣和爱好

DIY 这个爱好应该是遗传了我父亲的基因，我念初中时就好有兴趣翻他订阅的《无线电》杂志和《电子世界》杂志，后来逐步买些环氧树脂的单面铜板回来割，然后焊些东西、焊些东西，比如双稳态闪灯，串联二极管加电容的升压电路（当时觉得不用变压器升压实在太神奇了）。小时候还觉得不用发热就能发光是非常奇妙的事情，那时只有红色和绿色的LED，后来有了黄色（过了N年有了蓝色，后来居然有白色；又后来知道白色光不是晶体直接发出的）。。好吧，现在看回来我一直在折腾各样东西。

记得初中的物理老师是赵老师，我当时物理还不错。他曾经训斥过我，说要好好学习，表花太多时间玩这些东西，还不是时候。。不知道会不会有 DIYer 也是学霸，反正我一直不是。

上中学的时候跟邻居李均宇同学一起焊功放外，我还喜欢做 AM、FM 发射机器，我成功用一个 1.5V 电池，一个自己绕的线圈，一个电容，一个晶体 MIC 做出来好小的无线话筒，应该就跟下面这个说的差不多，，那时觉得连一个电阻都不用，1.5V就搞定，好厉害、好高兴

![](../images/extra/the_simplest_transmitter.png)

[http://thesimplesttransmitter.blogspot.com/](http://thesimplesttransmitter.blogspot.com/)

那个时候要 DIY 一个东西没有现在这么容易，以现在的条件很难想象当时的情形。你能想象没有网络，没有淘宝吗？没有所谓的物流。那时买无线电零件的最有效方式是翻无线电杂志的邮购目录，邮政汇款到浙江萧山的商户，商户用平邮发到本地邮政局，邮递员叔叔送来包裹领取通知单，然后哇啦哇啦地跑去邮政局领包裹。嗯对了，我的电路板基本是靠自己用木刻刀挖的，我邻居李同学喜欢用漆画好然后腐蚀。

how time flies...

后来上学念的是计算机软件，动烙铁的机会慢慢少了。但是 DIY 那根筋还在，所以总会想方法挤些时间来折腾。

---

## DIY projects and opensource projects

I am an EE fans, interested in electronic DIY started from childhood, let me post the latest stuff one by one later.

I have ever built several [redmine plugs](http://github.com/xuhui) for ALi company use and they are opensource, as the code was built for the open source redmine system, and not related to the key value/business of ALi company, so the projects are available in my github.

I am now interested in built some audio hardware, holp can do something not related to the company project but interesting in my spare time.

---

## Career

### 2015~

#### Marketing on New Product (Audio domain)

Survey/design/implement new product, shown at *2015 IBC, 2016 CES, 2016 IBC*

### 2010~2014

#### Lead of a software team in ALi Corp.

Built a new R&D team for new business

* Team building, from 1 to 40 R&D engineers
* Solution architect
* Management tools/flows development
* Achieved millions units shipment

---

## Technic skills

```
start from most recent
```

* Verilog HDL, recently interest in building a small logic on DIY audio project
* Routing tools, as I am a EE DIYer, mainly use EAGLE and sometimes PADS on my DIY boards
* Python, have fun with it
* Javascript/CSS
* Ruby, Rails
* iOS, xcode/OC
* Android Java (only a little bit know-how on it, no interest)
* C/C++（have ever built big things with)
* Assembly (x86, MIPS. re-implemented itron OS)
* Pascal (turbo pascal on DOS, delphi on windows, very old stories...)

---

## The plan on quick learning/survey (2017)

* System C
* Erlang

## The plan on next DIY projects (2017)

* A Clock connected with internet -- built with beautiful housing
* A LCD display connected with internet
* A Class-A headphone amplifier

---

# Other Interests

* Music
* Photography
* Travel
* Coding
* Blogging - I believe I will have more and more time on writing

---

## Find Xu Hui by

* email - [mail<EMAIL_ADDRESS>* github - [https://github.com/xuhui](https://github.com/xuhui)
* skype -<EMAIL_ADDRESS>* wechat - zhou_xu_hui

gha_language: JavaScript


text:
---
id: 16540
title: Chandler Powell
date: 2021-04-07T18:25:58+00:00
author: victor
layout: post
guid: https://ukdataservers.com/chandler-powell/
permalink: /04/07/chandler-powell/
---

* some text
{: toc}

## Who is Chandler Powell

Wakeboarder widely known for winning a triple crown title in 2014 and finishing top 3 in the Wake Park World Series.

## Prior to Popularity

He first learned to wakeboard at twelve years old in McCormicks Cable Park in Seffner, Florida.

## Random data

He has been sponsored by companies like Fuse and Liquid Force.

## Family & Everyday Life of Chandler Powell

His father, Chis Powell, participated in the first ever wakeboarding competition. In 2015, he gained media attention for beginning a relationship with Bindi Irwin. He and Bindi got married in 2020, and they welcomed a daughter named Grace Warrior Irwin Powell in March 2021.

## People Related With Chandler Powell

He has dated the daughter of Steve Irwin who’s better known as The Crocodile Hunter.


text:
---
title: Vertical Gauge
page_title: Xamarin Gauge Documentation | Vertical Gauge
description: Check our "Vertical Gauge" documentation article for Telerik Gauge for Xamarin control.
position: 2
slug: gauge-types-vertical
---

# Vertical Gauge

The **RadVerticalGauge** control allows you to display the scale's range in a linear form, vertically oriented.

## Setting up the gauge

The following example shows a **RadVerticalGauge**'s basic set up.

<snippet id='gauge-types-verticalgauge-xaml'/>
<snippet id='gauge-types-verticalgauge-code'/>

Here is the result:

![Vertical gauge example](../images/gauge-types-vertical-gauge-0.png)

>important A sample Vertical Gauge example can be found in the Gauge/GaugeTypes folder of the [SDK Samples Browser application]({%slug developer-focused-examples%}).

## See Also
- [Radial Gauge]({%slug gauge-types-radial%})
- [Horizontal Gauge]({%slug gauge-types-horizontal%})
- [Axis]({%slug gauge-axis%})
- [Indicators]({%slug gauge-indicators%})
- [Ranges]({%slug gauge-ranges%})

repository: telerik/xamarin-forms-docs

repo_name: telerik/xamarin-forms-docs


text:
# Autoscaling-over-time Dashboard

Leverage scaling-over-time dashboarding for your application autoscaling with Azure Durable Functions. 📊

This sample has been moved to [tomkerkhove/autoscaling-over-time-dashboard](https://github.com/tomkerkhove/autoscaling-over-time-dashboard).

repository: tomkerkhove/azure-autoscaling-toolbox

repo_name: tomkerkhove/azure-autoscaling-toolbox


text:
# **Changelog for PG3 Python Interface**

### Changes From 2.x

- normalized notices
- fixed all methods regarding the below changes to be backwards compatible for existing nodeservers, assuming they are using the getter/setter methods provided
- changed custom params and typed params API names to be more consistent: customparams, customdata, customtypedparams, customtypeddata, customparamsdoc, notices
- changed PG3 API interfaces to Array from object for addnode/customs/set/get/getAll
- fixed reconnect bug
- modified config input to remove custom\* and notices, moved to self.poly.custom = {}
- added response parsing for all messages sent to PG3
- fixed file formatting
- changed incoming listen/send topics for MQTT IPC
- MQTT TLS override fix
- change reading of init from stdin to ENV with base64 encoding (more reliable)
- removed .env checkfile function and warning
- add random_string function
- import base64/random/string (native modules)
- removed dotenv module


text:
Cinder-Samples
==============

Sample applications for the Cinder framework. In order to use these samples, clone this repository next to a clone of the Cinder Github repository like this:

[cinder_master]
* [blocks]
* [boost]
* [docs]
* ...

[cinder_samples]
* README.md
* [BouncingBalls]
* ...

To learn more about how to create a copy of the Cinder Github repository, visit: http://libcinder.org/docs/welcome/GitSetup.html

These code samples are compatible with the Microsoft Visual C++ (Express) 10 compiler. XCode support for MacOS X is not included, because I do not own an Apple and would not be able to update the project files.

The C++ and GLSL source code, however, should run on all platforms without modifications. I assume you run the samples on recent hardware, supporting shader model 4. I have tested the samples on NVIDIA GPU's, it might be possible that ATI GPU's may produce shader compilation errors. If you find an inconsistency or platform related bug, please notify me or create a pull request, so that I can fix the issues and make these samples as cross-platform as possible.

Find specific, sample related information in the sample's README.md files.

Thanks to all contributors and to the people behind the Cinder framework for doing an excellent job!

-Paul

Copyright (c) 2012, Paul Houx - All rights reserved. This code is intended for use with the Cinder C++ library: http://libcinder.org

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

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

repository: audionerd/Cinder-Samples

repo_name: audionerd/Cinder-Samples


text:
{#if readme.include-default-content}
{#if project.name}
# {project.name}
{#else}
# {project.artifact-id}
{/if}
{#if project.description}

> {project.description}
{/if}

This project uses Quarkus, the Supersonic Subatomic Java Framework.

If you want to learn more about Quarkus, please visit its website: https://quarkus.io/ .

## Running the application in dev mode

You can run your application in dev mode that enables live coding using:
```shell script
{buildtool.cli} {buildtool.cmd.dev}
```

> **_NOTE:_**  Quarkus now ships with a Dev UI, which is available in dev mode only at http://localhost:8080/q/dev/.

## Packaging and running the application

The application can be packaged using:
```shell script
{buildtool.cli} {buildtool.cmd.package}
```
It produces the `quarkus-run.jar` file in the `{buildtool.build-dir}/quarkus-app/` directory.
Be aware that it’s not an _über-jar_ as the dependencies are copied into the `{buildtool.build-dir}/quarkus-app/lib/` directory.

The application is now runnable using `java -jar {buildtool.build-dir}/quarkus-app/quarkus-run.jar`.

If you want to build an _über-jar_, execute the following command:
```shell script
{buildtool.cli} {buildtool.cmd.package-uber-jar}
```

The application, packaged as an _über-jar_, is now runnable using `java -jar {buildtool.build-dir}/*-runner.jar`.

## Creating a native executable

You can create a native executable using:
```shell script
{buildtool.cli} {buildtool.cmd.package-native}
```

Or, if you don't have GraalVM installed, you can run the native executable build in a container using:
```shell script
{buildtool.cli} {buildtool.cmd.package-native-container}
```

You can then execute your native executable with: `./{buildtool.build-dir}/{project.artifact-id}-{project.version}-runner`

If you want to learn more about building native executables, please consult {buildtool.guide}.
{#if input.selected-extensions}

## Related Guides

{#for ext in input.selected-extensions}
{#if ext.guide}
- {ext.name} ([guide]({ext.guide})): {ext.description}
{/if}
{/for}
{/if}
{#if input.provided-code}

## Provided Code
{/if}
{/if}

repository: quarkusio/quarkus

gha_language: Java

repo_name: quarkusio/quarkus


text:
},
        "proposal_title": "Webdevelopment",
        "proposal_created_at": "2017-11-24T10:30:40.113Z",
        "proposal_sent_at": null,
        "proposal_status": "draft",
        "proposal_public_id": "FYp1S4oBLxbNpQ",
        "proposal_expires_at": null,
        "client_name": "John",
        "client_email"<EMAIL_ADDRESS>        "client_surname": "Doe",
        "client_full_name": "John Doe",
        "client_business": "Company Name",
        "client_telephone": "1234567890",
        "client_locale": "en",
        "client_address": "Street Address",
        "client_postcode": "28017",
        "client_country": "Spain",
        "client_city": "Madrid",
        "client_state": "Madrid",
        "client_web": "example.com"
      }
    },
    {...}
  ],
  "meta": {
    "current_page": 1,
    "next_page": 2,
    "prev_page": null,
    "total_pages": 9,
    "total_count": 206
  }
}
```

This endpoint retrieves all proposal activities.

### HTTP Request

`GET https://app.nusii.com/api/v2/proposal_activities`

### Query Parameters

Parameter | Default | Description
--------- | ------- | -----------
proposal_id | null | Only get activities from a specific proposal
client_id | null | Only get activities from a specific client

## Get a Proposal Activity

```shell
curl -X GET \
  -H 'User-Agent: Your App Name (www.yourapp.com)' \
  -H 'Content-Type: application/json' \
  -H "Authorization: Token token=YOUR_API_KEY" \
  "https://app.nusii.com/api/v2/proposal_activities/44"
```

```ruby
require 'nusii-ruby'

Nusii.api_key = 'YOUR_API_KEY'
Nusii.user_agent = 'Your App Name (www.yourapp.com)'

activity = Nusii::ProposalActivity.get(44)
```

> The above command returns JSON structured like this:

```json
{
  "data": {
    "id": "44",
    "type": "proposal_activities",
    "attributes": {
      "activity_type": "user_send_proposal",
      "ip_address": "<IP_ADDRESS>",
      "additional_fields": {
        "to"<EMAIL_ADDRESS>        "cc"<EMAIL_ADDRESS>        "from"<EMAIL_ADDRESS>        "reply_to"<EMAIL_ADDRESS>        "subject": "You've received your proposal!",
        "bounce_type": "HardBounce",
        "bounced_email"<EMAIL_ADDRESS>        "bounce_description": "The server was unable to deliver your message (ex: unknown user, mailbox not found)."
      },
      "proposal_title": "Design for clientwebsite.com",
      "proposal_created_at": "2016-11-28T15:00:58.794Z",
      "proposal_sent_at": "2017-01-12T12:46:33.396Z",
      "proposal_status": "draft",
      "proposal_public_id": "smaBXa7wa1Jv",
      "proposal_expires_at": null,
      "client_name": "John",
      "client_email"<EMAIL_ADDRESS>      "client_surname": "Doe",
      "client_full_name": "John Doe",
      "client_business": "John Doe's Business",
      "client_telephone": "1234567890",
      "client_locale": "en",
      "client_address": "Street Address 29",
      "client_postcode": "28017",
      "client_country": "Spain",
      "client_city": "Madrid",
      "client_state": "Madrid",
      "client_web": "www.clientwebsite.com"
    }
  }
}
```

This endpoint retrieves a single proposal activity

### HTTP Request

`GET https://app.nusii.com/api/v2/proposal_activities/:id`

Parameter | Type | Description
--------- | ---- | -----------
activty_type | String | Type of activity. Possible values are: `client_view_proposal`, `client_view_pdf`, `user_create_proposal`, `user_view_proposal`, `user_send_proposal`, `user_manual_change_status_proposal`, `client_rejected_proposal`, `client_clarification_proposal`, `client_accepted_proposal`, `client_email_bounced`, `client_email_opened`, and `api_created_proposal`
ip_address | String | Ip address of the person that does the activity
additional_fields | Hash | An hash with additional information. Possible values are: `to` (email address where the proposal is sent), `cc` (cc email address where proposal is sent), `from` (email address where proposal is sent from), `reply_to` (reply to email address), `subject` (subject of email), `message` (the body of the email sent, or the reason of a proposal state change), `bounce_type` (set if email bounced), `bounce_description` (description why email bounced)
proposal_attributes | ... | Look at Proposal for information
client_attributes | ... | Look at Client for information

repository: michaelkoper/slate

repo_name: michaelkoper/slate


text:
{{
  properties: {
    category: "guides"
  }
}}

See Also: [Planning](/docs/guides/architecture), [views.Base](/docs/api/viewsbase), [views.List](/docs/api/viewslist), [views.Stack](/docs/api/viewsstack), [templates guide](/docs/guides/templates)

Views control what the user sees, and handles *all* user interactions invoked on its [template](/docs/guides/templates). Views are where your view-specific logic should go.

Views are also be composed of many nested views, or [children](/docs/api/viewsbase#children). Nesting views is a great way to organize your application, and greatly simplifies your view logic. Typically, it's easier to build views based on what you see in your initial HTML + CSS mockup. For instance, here's a mockup of the [TodoMVC example](https://github.com/mojo-js/mojo-todomvc-example):

Here's what the view structure looks like:

```
views/
  main/
    index.js - defines children views, and logic specific to the main view
    index.pc - defines where the children views should go
    header/
      index.js
      index.pc - controls new todo input
    todos/
      index.js - list of todos
      index.pc - defines where the list of todos should go
      todo/
        index.js - individual todo controller
        index.pc - todo template
    footer/
      index.js
      index.pc
```

Note that the `index` file is a common pattern used in CommonJS. It's similar to how `index.html` works. `require('./main')` for instance would automatically resolve to `./main/index.js`.

The `.pc` files are paperclip templates. In the TodoMVC example, there's a template for each view controller, and they're both named the same to show they go together.

filename: 2 Views.article.md


text:
Twitter4JAndroidLogin
=====================

Until Twitter decides to realease an offical SDK for Android, you can use this simple android library for logging into twitter and retrieving the user information.

This library is using the famous [Twiiter4J library](http://twitter4j.org/en/), and inspired by [ppierson/T4JTwitterLogin library](https://github.com/ppierson/T4JTwitterLogin); many thanks to [ppierson](https://github.com/ppierson)

This library allows you to retrive the **Twitter** object of Twitter4J after the authentication witch let you do all sort of things with the Twitter API.

###How To Login
--------------------

First of all, you need to register the following activity in your **AndroidManifest.xml**
```xml
<activity
	android:name="com.fadisdh.android.twitter4jlogin.TwitterLoginActivity"
<EMAIL_ADDRESS>	<intent-filter>
	    <action android:name="android.intent.action.VIEW" />
	    <category android:name="android.intent.category.DEFAULT" />
	    <category android:name="android.intent.category.BROWSABLE" />
	    <data android:scheme="x-oauthflow-twitter" android:host="twitterlogin"/>
	</intent-filter>
</activity>
```

Next, put this in your **onActivityResult()** method of the activity you are trying to connect from
```java
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
  super.onActivityResult(requestCode, resultCode, data);
  TwitterAdapter.getInstance().onActivityResult(requestCode, resultCode, data);
}
```

Finally, register your callback in the **onCreate()** method from the same activity. This callback will be called once you logged in. so all your twitter related code should be in the **success()** method of this callback.
Don't forget to change *{Your App Key}* and your *{Your App Secret}* to your actual twitter app key and secret.
```java

TwitterAdapter ta = TwitterAdapter.getInstance(this, "{Your App Key}", "{Your App Secret}");
TwitterAdapter.Callback callback = new TwitterAdapter.Callback(){

  @Override
  public void success(int type){
    //woohooo, you are logged in. Do stuff here
  }

  @Override
  public void failed(int type, Exception e){
    //the authentication failed. Do stuff here
  }
};
```

You can connect to twitter using **connect()** or **connect(callback)**
```java
ta.connect();
```

###How to Retrieve The User Data
--------------------

To retrieve user data use the following code. Remember, this code should be called from inside the **success()** method of the login callback
```java
ta.getUser(new TwitterAdapter.UserCallback(){

  @Override
  public void success(twitter4j.User user){
    //use the user object to retrieve the user data
  }

  @Override
  public void failed(Exception e){
    //failed, do stuff
  }
});
```

###Get The Twitter Object and The AccessToken of twitter4j library
--------------------

To get the **Twitter** object or the **AccessToken** object use the following code inside the **success()** method of the login callback
```java
Twitter t = ta.getTwitterInstance();
AccessToken at = ta.getAccessToken();
```
You can visit [Twiiter4J library](http://twitter4j.org/en/) website to know how to use the **Twitter object** to post a tweet, get the user timeline ... etc

###What's Next
--------------------

As you noticed, this library still needs a lot of work to be done. How about helping us?

###License
--------------------
This project is under [The MIT License](https://github.com/fadisdh/Twitter4JAndroidLogin/blob/master/LICENSE)


text:
---
title: Adding Components to Markdown with MDX
---

When writing long-form content in Markdown you might want to embed [components](/docs/glossary/#component).
This is often achieved by either writing content in JSX or using plugins that
use custom syntax. The first approach isn't optimal because JSX isn't the best
format for content and can make it less approachable to members of a team. Custom
syntax and plugins are often too inflexible and don't promote composition. If
you're finding yourself wanting to add components to your content you can use
`gatsby-plugin-mdx` which is a Gatsby plugin to integrate MDX into your project.

## What's MDX?

[MDX][mdx] is Markdown for the component era.
It lets you write JSX embedded inside Markdown.
It’s a great combination because it allows you to use Markdown’s terse
syntax (such as `# Heading`) for your content and JSX for more advanced,
or reusable components.

This is useful in content-driven sites where you want the ability
to introduce components like charts or alerts without having to
configure a plugin. It emphasizes composition over configuration
and really shines with interactive blog posts, documenting design
systems, or long form articles with immersive or dynamic
interactions.

When using MDX you can also import other MDX documents and render
them as components. This lets you write something like an FAQ
page in one place and reuse it throughout your website.

## What does it look like in practice?

Importing and JSX syntax works just like it does in your components. This
results in a seamless experience for developers and content authors alike.
Markdown and JSX are included alongside each other like this:

```markdown
import { Chart } from '../components/chart'

# Here’s a chart

The chart is rendered inside our MDX document.

<Chart />
```

## Features

❤ **Powerful**: MDX blends Markdown and JSX syntax to fit perfectly in
React/JSX-based projects.

💻 **Everything is a component**: Use existing components inside your
MDX and import other MDX files as plain components.

🔧 **Customizable**: Decide which component is rendered for each Markdown
element (`{ h1: MyHeading }`).

📚 **Markdown-based**: The simplicity and elegance of markdown remains;
you interleave JSX only when you want to.

🔥 **Blazingly blazing fast**: MDX has no runtime, all compilation occurs
during the build stage.

<GuideList slug={props.slug} />

[mdx]: https://mdxjs.com


text:
# Hamlit

[![Gem Version](https://badge.fury.io/rb/hamlit.svg)](http://badge.fury.io/rb/hamlit)
[![Build Status](https://travis-ci.org/k0kubun/hamlit.svg?branch=master)](https://travis-ci.org/k0kubun/hamlit)

Hamlit is a high performance [Haml](https://github.com/haml/haml) implementation.

## Introduction

### What is Hamlit?
Hamlit is another implementation of [Haml](https://github.com/haml/haml).
With some [limitations](REFERENCE.md#limitations) by design for performance,
Hamlit is **8.54x times faster** than original haml gem in [this benchmark](benchmark/slim/run-benchmarks.rb),
which is an HTML-escaped version of [slim-template/slim's one](https://github.com/slim-template/slim/blob/v3.0.6/benchmarks/run-benchmarks.rb) for fairness. ([Result on Travis](https://travis-ci.org/k0kubun/hamlit/jobs/93928561))

![Hamlit Benchmark](https://i.gyazo.com/ac9eb910c7261cc0181bd7427c860d79.png)

```
       hamlit v2.0.1:   122622.3 i/s
         faml v0.7.0:    94239.1 i/s - 1.30x slower
         slim v3.0.6:    89143.0 i/s - 1.38x slower
       erubis v2.7.0:    65047.8 i/s - 1.89x slower
  haml v5.0.0.beta.2:    14363.6 i/s - 8.54x slower
```

### Why is Hamlit faster?

#### Less string concatenation by design
As written in [limitations](REFERENCE.md#limitations), Hamlit drops some not-so-important features which require
works on runtime. With the optimized language design, we can reduce the string concatenation
to build attributes.

#### Temple optimizers
Hamlit is built with [Temple](https://github.com/judofyr/temple), which is a framework to build
template engines and also used in Slim. By using the framework and its optimizers, Hamlit can
reduce string allocation and concatenation easily.

#### Static analyzer
Hamlit analyzes Ruby expressions with Ripper and render it on compilation if the expression
is static. And Hamlit can also compile string literal with string interpolation to reduce
string allocation and concatenation on runtime.

#### C extension to build attributes
While Hamlit has static analyzer and static attributes are rendered on compilation,
dynamic attributes must be rendered on runtime. So Hamlit optimizes rendering on runtime
with C extension.

## Usage

See [REFERENCE.md](REFERENCE.md) for detail features of Hamlit.

### Rails

Add this line to your application's Gemfile or just replace `gem "haml"` with `gem "hamlit"`.
It enables rendering by Hamlit for \*.haml automatically.

```rb
gem 'hamlit'
```

If you want to use view generator, consider using [hamlit-rails](https://github.com/mfung/hamlit-rails).

### Sinatra

Replace `gem "haml"` with `gem "hamlit"` in Gemfile, and require "hamlit".
See [sample/sinatra](sample/sinatra) for working sample.

While Haml disables `escape_html` option by default, Hamlit enables it for security.
If you want to disable it, please write:

```rb
set :haml, { escape_html: false }
```

## Command line interface

You can see compiled code or rendering result with "hamlit" command.

```bash
$ gem install hamlit
$ hamlit --help
Commands:
  hamlit compile HAML    # Show compile result
  hamlit help [COMMAND]  # Describe available commands or one specific command
  hamlit parse HAML      # Show parse result
  hamlit render HAML     # Render haml template
  hamlit temple HAML     # Show temple intermediate expression

$ cat in.haml
- user_id = 123
%a{ href: "/users/#{user_id}" }

# Show compiled code
$ hamlit compile in.haml
_buf = [];  user_id = 123;
; _buf << ("<a href='/users/".freeze); _buf << (::Hamlit::Utils.escape_html((user_id))); _buf << ("'></a>\n".freeze); _buf = _buf.join

# Render html
$ hamlit render in.haml
<a href='/users/123'></a>
```

## Contributing

### Development

Contributions are welcomed. It'd be good to see
[Temple's EXPRESSIONS.md](https://github.com/judofyr/temple/blob/v0.7.6/EXPRESSIONS.md)
to learn Temple which is a template engine framework used in Hamlit.

```bash
$ git clone --recursive https://github.com/k0kubun/hamlit
$ cd hamlit
$ bundle install

# Run all tests
$ bundle exec rake test

# Run one test
$ bundle exec ruby -Ilib:test -rtest_helper test/hamlit/line_number_test.rb -l 12

# Show compiling/rendering result of some template
$ bundle exec exe/hamlit compile in.haml
$ bundle exec exe/hamlit render in.haml

# Use rails app to debug Hamlit
$ cd sample/rails
$ bundle install
$ bundle exec rails s
```

### Reporting an issue

Please report an issue with following information:

- Full error backtrace
- Haml template
- Ruby version
- Hamlit version
- Rails/Sinatra version

## License

Copyright (c) 2015 Takashi Kokubun

repository: rstacruz/hamlit

repo_name: rstacruz/hamlit


text:
# Ascocalyx abietis Naumov, 1925 SPECIES

#### Status
ACCEPTED

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Morbi Plant. Script. Sect. Phytopath. Hort. Bot. Prince. USSR 14: 138 (1925)

#### Original name
Ascocalyx abietis Naumov, 1925

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
---
layout: post
title: "Automatically Backing Up Firefox Bookmarks"
date: 2009-08-26T12:00:55-00:00
draft: false
author: "Brian Kloppenborg"
categories: ["backups", "old-content"]
tags: ["firefox"]
---
{% include JB/setup %}

Firefox can automatically export your bookmarks whenever the browser is closed
by setting the following field: Open up the about:config page (i.e. type
`about:config`` in the address bar) and set:

    browser.bookmarks.autoExportHTML = true

This will export your bookmarks to a file called "bookmarks.html" in your
profile directory (e.g.
`/home/$USER/.mozilla/firefox/\_uniqueID\_/bookmarks.html`
for Linux or inside of the
`C:\\Documents and Settings\\username\\Application Data\`
folder on Windows). That is useful, but if you want the bookmarks in a
convenient locaiton for some other automated backup process (i.e. rsync or
Offline Files) you should also tell Firefox where to place the file using the

    browser.bookmarks.file

setting in about:config. You will need to add the (string) key because it does
not exist by default:

With the (string) value being the location to which you want the file saved. For
Linux users you simply specify the full path and name of the file (i.e.
/home/$USER/bookmarks.html). For Windows users, you need to do the same but you
must include two slashes between the drive letter and path (i.e.
`C:\Documents and Settings\username\bookmarks.html``).

For more information, see Mozilla's documentation:
[browser.bookmarks.autoExportHTML](http://kb.mozillazine.org/Browser.bookmarks.autoExportHTML)
and [browser.bookmarks.file](http://kb.mozillazine.org/Browser.bookmarks.file)


text:
# Pumpt it up!
## Ensure availability of clean water by predicting the functionality of water points in Tanzania

This Repository presents my Capstone project of the neuefische Data Science Bootcamp in Hamburg at which I participated from February to May 2020. It is based on a data competition, held by [drivendata.org](https://www.drivendata.org/competitions/7/pump-it-up-data-mining-the-water-table/), named Pump it up!

![](figures/WATER_TZA.jpg)

##  Content of this repository

The repository contains mainly the following three notebooks:

* **PumpItUp_Cleaning_EDA_FE**
In the first notebook you will get an overview of the given data, the features and the target variable. This notebook contains the cleaning of the data (handling of missing values, eliminating features without information etc.) and the Data Exploration of the depencies between the features and the target variable. In the last section of this notebook

* **PumpItUp_Predictive_Modeling**
The second notebook the setup of machine learning models takes places. Therefore preprocessing pipelines are built and algorithms are trained to predict whether a water point is functional, broken or is still in function but needs to be maintened.

* **PumpItUp_PumpItUp_Maps_Visualization**
In the third and last notebook maps generated with folium for visualization purposes are stored. Finally this notebook contains a Future work section as well as some conclusions gained from this project.

additional contents:

* **README.md**
This file.
* **LICENSE**
* **data**
Folder to store the relevant data.
* **figures**
Folder to store the figures produced within the project.
* **maps_folium**
Folder to store html-files of created folium maps.


text:
> A batteries-included Django starter project. To learn more try the books [Django for Beginners](https://djangoforbeginners.com), [Django for APIs](https://djangoforapis.com), and [Django for Professionals](https://djangoforprofessionals.com).

https://github.com/wsvincent/djangox/assets/766418/a73ea730-a7b4-4e53-bf51-aa68f6816d6a

## 🚀 Features

- Django 4.2 & Python 3.11
- Install via [Pip](https://pypi.org/project/pip/) or [Docker](https://www.docker.com/)
- User log in/out, sign up, password reset via [django-allauth](https://github.com/pennersr/django-allauth)
- Static files configured with [Whitenoise](http://whitenoise.evans.io/en/stable/index.html)
- Styling with [Bootstrap v5](https://getbootstrap.com/)
- Debugging with [django-debug-toolbar](https://github.com/jazzband/django-debug-toolbar)
- DRY forms with [django-crispy-forms](https://github.com/django-crispy-forms/django-crispy-forms)
- Custom 404, 500, and 403 error pages
----

## Table of Contents
* **[Installation](#installation)**
  * [Pip](#pip)
  * [Docker](#docker)
* [Next Steps](#next-steps)
* [Contributing](#contributing)
* [Support](#support)
* [License](#license)

----

## 📖 Installation
DjangoX can be installed via Pip or Docker. To start, clone the repo to your local computer and change into the proper directory.

```
$ git clone https://github.com/wsvincent/djangox.git
$ cd djangox
```

### Pip

```
$ python -m venv .venv

# Windows
$ Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
$ .venv\Scripts\Activate.ps1

# macOS
$ source .venv/bin/activate

(.venv) $ pip install -r requirements.txt
(.venv) $ python manage.py migrate
(.venv) $ python manage.py createsuperuser
(.venv) $ python manage.py runserver
# Load the site at http://<IP_ADDRESS>:8000
```

### Docker

To use Docker with PostgreSQL as the database update the `DATABASES` section of `django_project/settings.py` to reflect the following:

```python
# django_project/settings.py
DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.postgresql",
        "NAME": "postgres",
        "USER": "postgres",
        "PASSWORD": "postgres",
        "HOST": "db",  # set in docker-compose.yml
        "PORT": 5432,  # default postgres port
    }
}
```

The `INTERNAL_IPS` configuration in `django_project/settings.py` must be also be updated:

```python
# config/settings.py
# django-debug-toolbar
import socket
hostname, _, ips = socket.gethostbyname_ex(socket.gethostname())
INTERNAL_IPS = [ip[:-1] + "1" for ip in ips]
```

And then proceed to build the Docker image, run the container, and execute the standard commands within Docker.

```
$ docker-compose up -d --build
$ docker-compose exec web python manage.py migrate
$ docker-compose exec web python manage.py createsuperuser
# Load the site at http://<IP_ADDRESS>:8000
```

## Next Steps

- Add environment variables. There are multiple packages but I personally prefer [environs](https://pypi.org/project/environs/).
- Add [gunicorn](https://pypi.org/project/gunicorn/) as the production web server.
- Update the [EMAIL_BACKEND](https://docs.djangoproject.com/en/4.0/topics/email/#module-django.core.mail) and connect with a mail provider.
- Make the [admin more secure](https://opensource.com/article/18/1/10-tips-making-django-admin-more-secure).
- `django-allauth` supports [social authentication](https://django-allauth.readthedocs.io/en/latest/providers.html) if you need that.

I cover all of these steps in my three books: [Django for Beginners](https://djangoforbeginners.com), [Django for APIs](https://djangoforapis.com), and [Django for Professionals](https://djangoforprofessionals.com).

----

## 🤝 Contributing

Contributions, issues and feature requests are welcome! See [CONTRIBUTING.md](https://github.com/wsvincent/djangox/blob/master/CONTRIBUTING.md).

## ⭐ Support

Give a ⭐  if this project helped you!

## License

[The MIT License](LICENSE)

repository: wsvincent/djangox

gha_language: Python

repo_name: wsvincent/djangox


text:
Raygun4Net is a small library that can listen to all unhandled exceptions in your Android and iOS applications and send the details to your [Raygun.com](https://raygun.com/?utm_source=xamarin-components) account. This allows you to see issues in your application as soon as your users encounter them alongside performance issues that are causing bad user experiences. Debug and release improvements and fixes for your customers faster than ever before using the Raygun software intelligence platform.

As you can see below, only a small amount of code is required to integrate this Raygun provider into your application. Full documentation is provided when you install this component, and a step-by-step guide is available when you create an application on your [Raygun.com](https://raygun.com/?utm_source=xamarin-components) dashboard.

In the code below, attaching both Crash Reporting and Real User Monitoring (Pulse) monitors the errors, crashes and performance issues affecting your users and presents them immediately for review within your Raygun dashboard.

```csharp
using Mindscape.Raygun4Net;
...

// Place this code somewhere in the main entry point of your application.
// For Android, make sure to pass in the main entry activity to the AttachPulse method.
RaygunClient.Initialize("YOUR_APP_API_KEY").AttachCrashReporting().AttachPulse();
```

[Sign up to Raygun.com](https://app.raygun.com/signup?utm_source=xamarin-components) to generate api keys for the above code and to view the error reports and performance data sent from your applications.


text:
# puppet-lint explicit Hiera class parameter lookup check

Extends puppet-lint to ensure there are no explicit calls to hiera()
in the class parameters.

[![Actions Status](https://github.com/deanwilson/puppet-lint-explicit_hiera_class_param_lookup-check/workflows/Ruby/badge.svg)](https://github.com/deanwilson/puppet-lint-explicit_hiera_class_param_lookup-check/actions)

In our code base we would rather have a class lookup values for its
parameters using Puppets automatic data binding functionality rather than
scatter a number of direct, unpredictably name spaced, hiera calls
throughout our manifests. This puppet-lint plugin helps us with that goal by
finding any explicit `hiera` calls in a classes parameter section.

    class no_explicit_lookups (
      $my_content = hiera('my::nested::key', 'baz')
    ) {
      file { '/tmp/foo':
        content => $my_content,
      }
    }

## Installation

To use this plugin add the following line to your Gemfile

    gem 'puppet-lint-explicit_hiera_class_param_lookup-check'

and then run `bundle install`.

## Usage

This plugin provides a new check to `puppet-lint`.

    explicit hiera() lookup of my::sample::key

## Other puppet-lint plugins

You can find a list of my `puppet-lint` plugins in the
[unixdaemon puppet-lint-plugins](https://github.com/deanwilson/unixdaemon-puppet-lint-plugins) repo.

### Author

[Dean Wilson](http://www.unixdaemon.net)

### License

 * MIT

gha_language: Ruby


text:
---
title: "regorafenib - Hepatocellular Carcinoma"
sidebar: mydoc_sidebar
permalink: regorafenibhepatocellularcarcinoma.html
toc: false
---

{% include image.html file="regorafenibhepatocellularcarcinoma.png" alt="regorafenibhepatocellularcarcinoma" %}

## Concepts

|------------|------|---------|
| Identifier | Name | Type    |
|------------|------|---------|
| MESH:C559147 | regorafenib | Disease |
| UniProt:P04049 | RAF proto-oncogene serine/threonine-protein kinase | Protein |
| UniProt:P15056 | Serine/threonine-protein kinase B-raf | Protein |
| UniProt:P16234 | Platelet-derived growth factor receptor alpha | Protein |
| UniProt:P11362 | Fibroblast growth factor receptor 1 | Protein |
| UniProt:P17948 | Vascular endothelial growth factor receptor 1 | Protein |
| UniProt:P35968 | Vascular endothelial growth factor receptor 2 | Protein |
| REACT:R-HSA-9006934 | Signaling by Receptor Tyrosine Kinases | Pathway |
| GO:0008284 | positive regulation of cell population proliferation | BiologicalProcess |
| GO:0045766 | positive regulation of angiogenesis | BiologicalProcess |
| MESH:D006528 | Hepatocellular Carcinoma | Disease |
|------------|------|---------|

## Relationships

|---------|-----------|---------|
| Subject | Predicate | Object  |
|---------|-----------|---------|
| Regorafenib | DECREASES ACTIVITY OF | Raf Proto-Oncogene Serine/Threonine-Protein Kinase |
| Regorafenib | DECREASES ACTIVITY OF | Serine/Threonine-Protein Kinase B-Raf |
| Regorafenib | DECREASES ACTIVITY OF | Platelet-Derived Growth Factor Receptor Alpha |
| Regorafenib | DECREASES ACTIVITY OF | Fibroblast Growth Factor Receptor 1 |
| Regorafenib | DECREASES ACTIVITY OF | Vascular Endothelial Growth Factor Receptor 1 |
| Regorafenib | DECREASES ACTIVITY OF | Vascular Endothelial Growth Factor Receptor 2 |
| Raf Proto-Oncogene Serine/Threonine-Protein Kinase | PARTICIPATES IN | Signaling By Receptor Tyrosine Kinases |
| Serine/Threonine-Protein Kinase B-Raf | PARTICIPATES IN | Signaling By Receptor Tyrosine Kinases |
| Platelet-Derived Growth Factor Receptor Alpha | PARTICIPATES IN | Signaling By Receptor Tyrosine Kinases |
| Fibroblast Growth Factor Receptor 1 | PARTICIPATES IN | Signaling By Receptor Tyrosine Kinases |
| Vascular Endothelial Growth Factor Receptor 1 | PARTICIPATES IN | Signaling By Receptor Tyrosine Kinases |
| Vascular Endothelial Growth Factor Receptor 2 | PARTICIPATES IN | Signaling By Receptor Tyrosine Kinases |
| Signaling By Receptor Tyrosine Kinases | CONTRIBUTES TO | Positive Regulation Of Cell Population Proliferation |
| Signaling By Receptor Tyrosine Kinases | CONTRIBUTES TO | Positive Regulation Of Angiogenesis |
| Positive Regulation Of Cell Population Proliferation | CAUSES | Hepatocellular Carcinoma |
| Positive Regulation Of Angiogenesis | CAUSES | Hepatocellular Carcinoma |
|---------|-----------|---------|

Reference: [https://go.drugbank.com/drugs/DB08896#mechanism-of-action](https://go.drugbank.com/drugs/DB08896#mechanism-of-action){:target="_blank"}

repository: patrickrewers/DrugMechDB

repo_name: patrickrewers/DrugMechDB