text:
# **Behavioral Cloning**

**Behavioral Cloning Project**

The goals / steps of this project are the following:
* Use the simulator to collect data of good driving behavior
* Build, a convolution neural network in Keras that predicts steering angles from images
* Train and validate the model with a training and validation set
* Test that the model successfully drives around track one without leaving the road
* Summarize the results with a written report

## Rubric Points
### Here I will consider the [rubric points](https://review.udacity.com/#!/rubrics/432/view) individually and describe how I addressed each point in my implementation.

---
### Files Submitted & Code Quality

#### 1. Submission includes all required files and can be used to run the simulator in autonomous mode

My project includes the following files:
* model.py contains model. Preprocessing of data is part of model.
* train.py is the script to train by model defined in model.py.
* drive.py for driving the car in autonomous mode and save images.
* model.h5 containing a trained weight of model defined in model.py.
* video.py is for create video from images contained in a folder.
* video.mp4 shows model driving performance.
* video_simulator.mp4 is screen recording (4x speed) of simulator run on autonomous mode.
* writeup.md summarizing the results.

[//]: # (Image References)

[model]: ./examples/model_plot.png
[center1]: ./examples/center_1.jpg
[center2]: ./examples/center_2.jpg
[left_center1]: ./examples/left_center_1.jpg
[left_center2]: ./examples/left_center_2.jpg
[right_center1]: ./examples/right_center_1.jpg
[right_center2]: ./examples/right_center_2.jpg
[left_turn]: ./examples/left_turn.jpg
[right_turn]: ./examples/right_turn.jpg

#### 2. Submission includes functional code
Using the Udacity provided simulator and my drive.py file, the car can be driven autonomously around the track by executing
```sh
python drive.py model.h5
```

#### 3. Submission code is usable and readable

The model.py file contains the code for model and preprocessing is part of model.

The train.py shows the pipeline I used for training and validating the model, and it contains comments to explain how the
code works.

### Model Architecture and Training Strategy

#### 1. An appropriate model architecture has been employed

This modle is "MobileNet" model of "ImageNet" without last fully connected layers. Its first 40 layes are freezed
(can not be trained). As "MobileNet" supports some specific images sizes so image preprocessing is added as input layes
Lambda function. Finally flatten the "MobileNet" output and added two Dense layer.

Preprocessing has following two steps:
* Resize input image to support "MobileNet" supported input size. We have used (160, 320, 3) to (160, 160, 3).
* "MobileNet" model requires normalized image which pixel value should be between -1, 1. Used keras supported preprocess
function of "MobileNet" model.

#### 2. Attempts to reduce overfitting in the model

The model contains two dropout layers in order to reduce overfitting after flatten and first dense layer.

The model was trained and validated on different data sets to ensure that the model was not overfitting.
The model was tested by running it through the simulator and ensuring that the vehicle could stay on the track.

#### 3. Model parameter tuning

The train.py uses an adam optimizer to train model in model.py. Tried diffrent learning rate but 0.001 worked best,
which is also default of adam optimizer.

#### 4. Appropriate training data

I have used given training data. Only use images of central camera.
As we have less number of right curved lane date, horizontally fliped images and its negative steering mesurnments is used
to increase training data and get sufficient right turn images.

### Model Architecture and Training Strategy

#### 1. Solution Design Approach

Choosen smallest sized imagenet model supported in keras-2.0.8. Removed the final layer instead of that
added two dense layers. To deal with overfitting two dropout layers is also added. To feed our image input size
lambda layer for preprocessing is added (details are in model.py).

Chossen pretrained model "MobileNet" with "ImageNet" weight. Freezed first fourty layers. As intitial layers has generaral
features (i.e. edges), which moldel has to learn in any trainings. In our cases we had to learn lane lines edges. Purpose of
trnsfer learning was to reduce train time and have good edges features of "MobileNet" model.

Although number of epochs is 30, but model stop improving validation loss after 7 only. Validation loss in our case was
0.097 (mean square error). Its traing was pretty fast.

Finally model performance was tested on simulator. I have tested on maximum supported speed (approx 30 MPH) of simulator.
Its runs preety well. Its means relatively big size of model has good enough response time to handle this speed.

#### 2. Final Model Architecture

Our final model architecture can be shown by following image.

![alt text][model]

#### 3. Creation of the Training Set & Training Process

To capture good driving behavior, I first recorded two laps on track one using center lane driving. Here are example images
of center lane driving:

![alt text][center1] ![alt text][center2]

I then recorded the vehicle recovering from the left side and right sides of the road back to center so that the
vehicle would learn to recover if deviated from center of lane.

* Example images to recover from left

![alt text][left_center1] ![alt text][left_center2]

* Example images to recover from right

![alt text][right_center1] ![alt text][right_center2]

To augment the data set, flipped images and take negative of steering angle mesurnment for flipped images. By this
agumentation technique training example become twice and also balance examples for left and right turn lane lines.
An example of fliped image.

![alt text][right_turn] ![alt text][left_turn]

I finally randomly shuffled the data set and put 20% of the data into a validation set.

I used this training data for training the model. The validation set helped determine if the model was over or under fitting.
Number of epochs was 30 with early stoping callbacks. Found that in 7 epochs validation error stoped improving.
Uses adam optimizer with learning rate 0.001. Validation mse error was 0.097.


text:
gophersql
=========

Database/SQL talk for Denver Gophers. Drivers and code examples are on the [package page](http://golang.org/pkg/database/sql/).

### Recommended Drivers

* [Postgres](https://github.com/lib/pq)
* [SQLite3](https://github.com/mattn/go-sqlite3)
* [MySQL](https://github.com/ziutek/mymysql)

Examples
--------

Import syntax, the empty `_` import

Building the connection string

Knowing the parameterization scheme

`Exec` versus `Query`

Scanning into pointers

Closing rows

The scanner interface

Cross-platform issues

Talk `struct` with the database!

Issues
------

### Zero-initialization

Default `INSERT` values and dealing with `NULL` values with pointers or Null types.

### Closing rows and duplicate connections with :memory:

The case of the disappearing table.

### Scanning into an interface

Strings are scanned as `[]byte`, resulting in unexpected `json` output.

### No interface for connections and transactions

Build one to test instances requiring a connection

Packages
--------

A list of popular projects

* [sqlx](https://github.com/jmoiron/sqlx) - provides a super-set of the `database/sql` library
* [Goose](https://bitbucket.org/liamstask/goose) - database migrations
* [Go Relational Persistence](https://github.com/coopernurse/gorp) - talk `struct` with the database
* [GORM](https://github.com/jinzhu/gorm) - talk `struct` with the database

And my own: [Aspect](https://github.com/aodin/aspect) - cross-dialect query construction, schema declarations, and talking a variety of types with the database (including structs and slices)

license: MIT

repository: aodin/gophersql

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: aodin/gophersql


text:
## update the fork project use command line
> without the pull request which difficult use.
1. set upstream `git remote add upstream https://github.com/ORIGINAL_OWNER/ORIGINAL_REPOSITORY.git` (https://help.github.com/articles/configuring-a-remote-for-a-fork/)
2. fetch upstream `git fetch upstream`
3. checkout your target branch `git checkout master`
4. merge the upstream branch to your branch `git merge upstream/master`
5. push the merge

use `git remote -v` to check the upstream branchs.[see more](https://help.github.com/articles/syncing-a-fork/).


text:
# Clustering_Philippine_Household_Consumption
K-means unsupervised learning on Philippine household consumption data

## Background

I saw a large dataset of household consumption patters in the Philippines, and wondered if the data could easily be clustered.  This is my exploration of that data to see if there were clear trends among food expendatures among households.

## Installation

Clone the GitHub repository and use Conda to start a new environment using python and install associated packages. Then open the Jupyter Notebook.

$ git clone https://github.com/briantfriederich/Clustering_Philippine_Household_Consumption
$ cd ~/Clustering_Philippine_Household_Consumption
$ conda create -n cphc python=2
$ source activate cphc
$ jupyter notebook

## License

This project is released under the MIT License.


text:
---
layout: linkpost
title: "The Soundtrack to April 2013"
date: 2013-04-03 08:15
comments: true
link: http://sharemyplaylists.com/the-soundtrack-to-april-2013
---

![](/public/images/2013/04/03/soundtrack-april-2013.jpg)

Another month, another _Soundtrack_ by [Phil Wilce][wilce]. If you're interested in new music this series of Spotify playlists are must-listens!

> April is fully loaded. 50 live rounds. All hit the bulls-eye.
>
> From the raucous hellfire of Major Lazer and Tyga. To the deadly sniper attack of Misty Miller and Kodaline.
>
> There are carefully picked-off targets from the new albums by Peace, Low, Devendra Banhart and Steve Mason
>
> And a brutal attack from Vision.
>
> [http://www.twitter.com/iamnottheenemy][wilce] + [http://thesoundtrackto.tumblr.com][tst-tumblr]
>
> Aim. Fire. This is the Soundtrack to April 2013.

[wilce]: http://www.twitter.com/iamnottheenemy "Phil Wilce on Twitter"
[tst-tumblr]: http://thesoundtrackto.tumblr.com "The Soundtrack to..."

extension: markdown


text:
# Configuration

Adjust the definitions of the macros in the `include/config.h` file.

# Instructions

1. Modify the script to adjust configuration options as desired, then execute it to install all dependencies and configure the system:

```
nano ./scripts/setup.sh
sudo ./scripts/setup.sh
```

## HerQules

1. Select an interface to use for communication between the runtime and verifier:

* `MODEL`: Models the behavior of AppendWrite in software using a [POSIX shared memory](http://man7.org/linux/man-pages/man7/shm_overview.7.html) interface (`/dev/shm/HQ`). For performance testing only; messages are not actually append-only.
* `MODEL_SIM`: Models the behavior of AppendWrite in a hardware simulator, using a dummy instruction for AppendWrite. For simulator performance testing only; messages are not actually sent.
* `OPAE`: Implements AppendWrite in a FPGA using the [OPAE](https://01.org/OPAE) interface. Requires a compatible [Intel Programmable Accelerator Card](https://www.intel.com/content/www/us/en/programmable/solutions/acceleration-hub/platforms.html). Complete [setup instructions below](#intel-programmable-acceleration-card-pac) before continuing.
* `POSIX_FIFO`: Implements a [POSIX named pipe (FIFO)](http://man7.org/linux/man-pages/man7/fifo.7.html) interface (`/tmp/HQ`).
* `POSIX_MQ`: Implements a [POSIX message queue](http://man7.org/linux/man-pages/man7/mq_overview.7.html) interface (`/dev/mqueue/HQ`).
* `POSIX_SHM`: Implements a [POSIX shared memory](http://man7.org/linux/man-pages/man7/shm_overview.7.html) interface (`/dev/shm/HQ`). For performance testing only; messages are not actually append-only.
* `SOCKETS_UNIX`: Implements a [UNIX domain socket](https://man7.org/linux/man-pages/man7/unix.7.html) interface (`/tmp/HQ`).
* `DPDK`: Implements AppendWrite in a NIC using the [DPDK](https://www.dpdk.org) interface. Requires a [compatible multi-port NIC](https://ark.intel.com/content/www/us/en/ark/products/88209/intel-ethernet-converged-network-adapter-x550-t2.html), with each processor core assigned to a unique NIC port, and all assigned ports connected to the same network or loopback. For testing only; suffers from various DPDK limitations. Logs are written to `/tmp/dpdk.<pid>.log`.
* `NONE`: Implements a dummy interface that does not receive or send messages. For testing only.
* `PAGES`: Implements a dummy interface that does not receive messages, but uses a kernel module (`pages`) to send messages to physical memory pages, which can be either write-through, write-combining, or uncached. For testing only.
* `ZERO`: Implements a dummy interface that does not receive messages, but sends them to an anonymous zero page. For testing only.

2. Build or download our modified LLVM compiler toolchain. See [setup instructions below](#compiler-clangllvm).

4. Build and compile the HerQules framework, including FPGA bitstream, compiler instrumentation, runtime library, and verifier application, as follows. To support inlining our messaging interface, also pass `-DBUILD_RTLIB_INLINE=ON` to CMake, but this is not compatible with all interfaces.

```
mkdir build
cd build
cmake -DCMAKE_BUILD_TYPE=Release -DLLVM_DIR=$CLANG_HQ/lib/cmake/llvm -DINTERFACE=<interface> ..
make
export BUILD_PATH=`pwd`
export CFLAGS_CFI+=" -fplugin=$BUILD_PATH/llvm/libcfi.so"
export LDFLAGS_CFI+=" -Wl,-z,now -Wl,-z,relro -fplugin=$BUILD_PATH/llvm/libcfi.so"
```

5. Build our modified standard runtime libraries. See [setup instructions below](#standard-runtimes-musl-libstdc).

6. Initialize the interface and execute the verifier. See [setup instructions below](#verifier).

7. Build and execute applications. See [setup instructions below](#applications).

## Intel Programmable Acceleration Card (PAC)

1. If not installed already by the setup script, install [OPAE](https://github.com/OPAE/opae-sdk) from source:

```
mkdir build
cd build
cmake -DCPACK_GENERATOR=DEB ..
make package_deb
dpkg -i *.deb
```

2. Depending on hardware, install the appropriate Intel Acceleration Stack for Development, including the bundled Quartus Prime, but skip the bundled OPAE, which is likely outdated. If you are using an unsupported version of Ubuntu, you will need to modify the installer `setup.sh` script to set `is_ubuntu=1`:

* Arria 10 GX: [v1.2.0](https://www.intel.com/content/www/us/en/programmable/f/download/accelerator/eula.html?swcode=WWW-SWD-ASD-12) with [v1.2.0 Update 1](https://www.intel.com/content/www/us/en/programmable/f/download/accelerator/eula.html?swcode=WWW-SWD-DCP-A10-GX-PAC-PV-12-UPDATE)
<!-- * Arria 10 GX: [v1.2.1](https://www.intel.com/content/www/us/en/programmable/f/download/accelerator/eula.html?swcode=WWW-SWD-IAS-A10-GX-PAC-PV-DEV-121) -->
* Stratix 10 SX: [v2.0.1](https://www.intel.com/content/www/us/en/programmable/f/download/accelerator/license-agreement-pac-d5005.html?swcode=WWW-SWD-IAS-DEV-201)

3. To simulate the bitstream, [Synopsys VCS-MX](https://www.synopsys.com/verification/simulation/vcs.html) and the `opae-ase` package must be installed. Note that the simulator environment does not support memory mapping or shared access, so any usage of memory-mapped I/O will not work.

4. When [configuring HerQules](#HerQules), pass the following additional arguments to CMake `-DINTEL_PAC_SDK=<sdk path> -DBUILD_FPGA_BITSTREAM=ON -DBUILD_FPGA_SIMULATION=OFF`, as desired. A test OPAE application can also be built by passing `-DBUILD_TESTS_FPGA=ON`, but this requires installation of [BBB_cci_mpf](https://github.com/OPAE/intel-fpga-bbb) and libuuid. Note that a pre-built bitstream for the Arria 10 is available under GitHub Releases.

5. After HerQules has been built, program the bitstream and/or run the simulation, as follows:

* Bitstream: Program the Intel PAC with the bitstream file using `sudo fpgaconf -V build/fpga/bitstream/hq_fifo.gbs`.

* Simulation: Run `make sim` in the `<build>/fpga/simulation` directory to execute the simulator. In another terminal, follow the simulator instructions to set the `ASE_WORKDIR` environment variable, then execute the target program in the simulator using `with_ase <program>`.

## Compiler (Clang/LLVM)

1. Obtain our modified Clang/LLVM compiler toolchain, which supports plugin passes during LTO, includes additional optimizations, does not discard value names and lifetime markers, and is configured with a default target triple and system root directory for musl cross-compilation. Either:

* Use the pre-built binaries under GitHub Releases, and extract to e.g. `llvm/llvm-project/llvm/build_release`.
* Build the `llvm-project` submodule from source, as follows:

```
cd llvm/llvm-project/llvm
mkdir build_release
cd build_release
cmake -DCMAKE_BUILD_TYPE=RelWithDebInfo -DLLVM_CCACHE_BUILD=ON -DLLVM_BINUTILS_INCDIR=/usr/include -DLLVM_ENABLE_PROJECTS=clang -DLLVM_ENABLE_RUNTIMES=compiler-rt -DLLVM_TARGETS_TO_BUILD=X86 -DLLVM_DEFAULT_TARGET_TRIPLE=x86_64-pc-linux-musl -DDEFAULT_SYSROOT=/opt/cross -DLLVM_USE_LINKER=gold -DLLVM_CCACHE_BUILD=ON -DLLVM_OPTIMIZED_TABLEGEN=ON -DLLVM_LINK_LLVM_DYLIB=ON -DLLVM_USE_SPLIT_DWARF=ON -DLLVM_USE_GDB_INDEX=ON -DLLVM_ENABLE_DUMP=ON -GNinja ..
ninja
```

2. Set the appropriate environment variables to refer to the original and modified Clang/LLVM compiler toolchains:

```
export CLANG_NONE="clang-10"
export CLANGXX_NONE="clang++-10"

export CLANG_HQ="<llvm path>"
export CLANG_CFI="$CLANG_HQ/bin/clang"
export CLANGXX_CFI="$CLANG_HQ/bin/clang++"
```

## Standard Runtimes (musl, libstdc++)

1. Obtain a cross-compile environment that uses the musl C runtime library, either:

* Use the pre-built binaries under GitHub Releases, and extract to `/opt/cross`.
* Build the `musl-cross-make` and `musl` submodules from source, as follows:

```
cd rtlib/musl-cross-make
make
sudo make install
sudo rm -r /opt/cross/x86_64-pc-linux-musl/include
cd /opt/cross/x86_64-pc-linux-musl
sudo ln -s ../include include
sudo ln -s /usr/include/sys/queue.h include/sys/queue.h
```

2. Create a copy of this cross-compile environment for baseline experiments, and configure it:

```
sudo cp -r /opt/cross /opt/cross-none
sudo ln -s /opt/cross-none/x86_64-pc-linux-musl/lib/libc.so /lib/ld-musl-none-x86_64.so.1
echo "/opt/cross-none/x86_64-pc-linux-musl/lib" | sudo tee /etc/ld-musl-none-x86_64.path
```

3. Create the instrumented cross-compile environment, by rebuilding the musl C runtime library with the HerQules runtime library and system call instrumentation, overwriting the uninstrumented one, and configuring it:

```
export HQ_SYSCALLS_ONLY=1
cd rtlib/musl
mkdir build
cd build
CC=$CLANG_CFI CXX=$CLANGXX_CFI CFLAGS+=" -fplugin=$BUILD_PATH/llvm/libcfi.so" LDFLAGS+=" -L$BUILD_PATH/rtlib -Wl,--whole-archive -lrtlib -Wl,--no-whole-archive" ../configure
make
sudo cp lib/libc.* /opt/cross/x86_64-pc-linux-musl/lib/
unset HQ_SYSCALLS_ONLY
sudo ln -s /opt/cross/x86_64-pc-linux-musl/lib/libc.so /lib/ld-musl-x86_64.so.1
echo "/opt/cross/x86_64-pc-linux-musl/lib" | sudo tee /etc/ld-musl-x86_64.path
```

## Verifier

1. Load the HerQules kernel interface:

```
sudo insmod kernel/hq.ko
```

2. Initialize the selected message interface, if needed:

* `DPDK`: `sudo modprobe vfio_pci; sudo dpdk-devbind -b vfio-pci <nic pci id>; export XDG_RUNTIME_DIR=/var/run; sudo chmod a+rwx -R /var/run/dpdk; sudo chmod a+rw -R /dev/hugepages; sudo chmod a+rw -R /dev/vfio`
* `OPAE`: `sudo chmod a+rw /dev/intel-fpga-port.0`
* `PAGES`: `sudo insmod kernel/pages/pages.ko`

3. Execute the verifier:

```
sudo ./verifier/verifier
```

## Applications

1. Set the compiler flags for building applications, as shown below. Certain variables are used only to build the baseline (`CLANG_NONE`, `CLANGXX_NONE`, `CFLAGS_NONE`, `LDFLAGS_NONE`), whereas others are used to build with HerQules and CFI (`CLANG_CFI`, `CLANGXX_CFI`, `CFLAGS_CFI`, `LDFLAGS_CFI`). Devirtualization optimizations can be enabled by expanding the `OPT` variable when building. Inlining of the messaging interface can enabled by setting the variable `HQ_INLINE_PATH`: `export HQ_INLINE_PATH=$BUILD_PATH/rtlib/rtlib_msg.o`.

```
export OPT+=" -fstrict-vtable-pointers -fforce-emit-vtables -fvirtual-function-elimination -fwhole-program-vtables"

export CFLAGS_NONE+=" --target=x86_64-pc-linux-musl --sysroot=/opt/cross-none --gcc-toolchain=/opt/cross-none -flto -fvisibility=hidden"
export LDFLAGS_NONE+=" -Wl,-z,now -Wl,-z,relro --target=x86_64-pc-linux-musl --sysroot=/opt/cross-none --gcc-toolchain=/opt/cross-none -flto -fuse-ld=gold -Wl,--dynamic-linker=/lib/ld-musl-none-x86_64.so.1"

export CFLAGS_CFI+=" -flto -fvisibility=hidden -fsanitize=cfi-nvcall,cfi-vcall,cfi-icall,cfi-mfcall,safe-stack"
export LDFLAGS_CFI+=" -flto -fuse-ld=gold -fsanitize=safe-stack"
```

### Sample Application

1. Compile this application with CFI and optimizations, which should produce similar output:

```
$ $CLANGXX_CFI $CFLAGS_CFI $OPT -O3 ../tests/general.cpp -c -o general.o
../tests/general.cpp: Instrumented 0 system calls, function pointers (4 defines, 0 invalidates), vtable pointers (0 defines, 2 invalidates), 10 uses

$ $CLANGXX_CFI $LDFLAGS_CFI $OPT -O3 -o general general.o
ld-temp.o: Finalized away pointers (1 defines, 2 checks, 0 check-invalidates, 0 invalidates), inserted calls (0 copies/moves, 0 frees), and instrumented globals (1 recursion guards, 6 function pointers, 0 vtable pointers | 6 internal, 0 external)
```

2. Execute this application, which should produce similar output:

```
$ ./general
Test: Function pointers
Called: char *f1()
Called: char *f1()
Called: char *f1()
Called: char *f1()
Test: C++ virtual calls
Called: virtual void Bar::f() const
Called: virtual void Bar::f() const
Test: C++ member functions
Called: virtual void Bar::f() const
Test: Dominated load
Called: char *f2()
Called: char *f2()
Called: char *f2()
Called: char *f2()
Test: Longjmp/setjmp
Called: char *f2()
Test: Corrupt
Called: char *f3()
Killed
```

### RIPE

1. Build the attack generator as follows. Note that we repurpose the 'GCC' build as the baseline without HerQules or our CFI scheme.

```
cd tests/ripe
GCC=$CLANG_NONE CLG=$CLANG_CFI GCC_CFLAGS="$CFLAGS_NONE" GCC_LDFLAGS="$LDFLAGS_NONE" CLG_CFLAGS="$CFLAGS_CFI" CLG_LDFLAGS="$LDFLAGS_CFI" make
```

2. Disable ASLR:
```
echo 0 | sudo tee /proc/sys/kernel/randomize_va_space
```

3. Run RIPE, with up to 3 tries for each attack.

```
./ripe_tester.py both 3 both
```

### LLVM Test Suite / SPEC Benchmarks

1. Patch the SPEC benchmarks:

```
cd <spec2006_path>; for i in <repo path>/tests/patches/4*.patch; do patch -p1 < $i; done
cd <spec2017_path>; for i in <repo path>/tests/patches/5*.patch; do patch -p1 < $i; done
```

2. Build the test suite, as shown below. Insert `OPT`, and/or substitute the appropriate variables for `CLANG`, `CLANGXX`, `CFLAGS`, and `LDFLAGS`, depending on the desired build configuration. Note that the test suite only supports the Release build mode.

```
cd tests/llvm-test-suite
mkdir build
cd build
cmake -DTEST_SUITE_SUBDIRS=External -DCMAKE_C_COMPILER=$CLANG -DCMAKE_CXX_COMPILER=$CLANGXX -C../cmake/caches/O3.cmake -DTEST_SUITE_SPEC2006_ROOT=<spec2006_path> -DTEST_SUITE_SPEC2017_ROOT=<spec2017_path> -DCMAKE_CXX_FLAGS="$CFLAGS" -DCMAKE_C_FLAGS="$CFLAGS" -DCMAKE_EXE_LINKER_FLAGS="$LDFLAGS" -DTEST_SUITE_USE_PERF=ON -DTEST_SUITE_RUN_TYPE=ref -DTEST_SUITE_COLLECT_CODE_SIZE=OFF -GNinja ..
ninja
```

3. If LLVM was not built from source, install the [lit](https://pypi.org/project/lit/) tool, as shown below. Otherwise, it should already be built as `$CLANG_HQ/bin/llvm-lit`.

```
pip install lit
```

4. Execute all SPEC benchmarks, then run a script to combine user-space performance statistics into `External/out.csv`:

```
<path to lit/llvm-lit> External/SPEC --time-tests -j1
./scripts/combine.py tests/llvm-test-suite/build/External
```

5. Alternatively, to run all benchmarks three times with a specified timeout in seconds, and save results with a given filename prefix:

```
./scripts/run.sh <prefix> <timeout>
```

### NGINX

1. Configure and build NGINX, as shown below. Insert `OPT`, and/or substitute the appropriate variables for `CLANG`, `CLANGXX`, `CFLAGS`, and `LDFLAGS`, depending on the desired build configuration.

```
./configure --with-cc=$CLANG --with-cpp=$CLANGXX --with-cc-opt="$CFLAGS -Wno-sign-compare" --with-ld-opt="$LDFLAGS" --without-http_rewrite_module --without-http_gzip_module --prefix=`pwd`/root
make -j install
```

2. Run NGINX:

```
./root/sbin/nginx
```

#### WRK: HTTP Benchmarking

1. Build the benchmarking tool:

```
cd tests/wrk
make -j
```

2. Run the benchmark against the local NGINX webserver:

```
./wrk --latency -t 1 -d 60s http://localhost:8080
```

repository: secure-foundations/herqules

repo_name: secure-foundations/herqules


text:
# Data

The dataset for this package, known as the Cook County Assessor's Residential Sales Data, can be found on Cook County's [open data portal](https://datacatalog.cookcountyil.gov/Property-Taxation/Cook-County-Assessor-s-Residential-Sales-Data/5pge-nu6u).

repository: ds-modules/HCE-Materials

path: /Cook County/data/README.md

branch_name: refs/heads/main

repo_name: ds-modules/HCE-Materials


text:
# Schizothecium hispidulum (Speg.) N. Lundq., 1972 SPECIES

#### Status
ACCEPTED

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

#### Published in
Symb. bot. upsal. 20(no. 1): 254 (1972)

#### Original name
Sordaria hispidula Speg., 1898

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
# Bang & Olufsen Beoplay H6 2nd Gen
See [usage instructions](https://github.com/jaakkopasanen/AutoEq#usage) for more options and info.

### Parametric EQs
In case of using parametric equalizer, apply preamp of **-7.7dB** and build filters manually
with these parameters. The first 5 filters can be used independently.
When using independent subset of filters, apply preamp of **-7.4dB**.

| Type    | Fc       |    Q | Gain    |
|:--------|:---------|:-----|:--------|
| Peaking | 70 Hz    | 0.66 | -4.0 dB |
| Peaking | 230 Hz   | 1.86 | 4.9 dB  |
| Peaking | 3273 Hz  | 0.31 | -7.9 dB |
| Peaking | 3404 Hz  | 1.31 | 12.7 dB |
| Peaking | 5721 Hz  | 2.5  | 9.4 dB  |
| Peaking | 21 Hz    | 2.88 | 3.0 dB  |
| Peaking | 137 Hz   | 5.13 | -4.7 dB |
| Peaking | 146 Hz   | 2.52 | 2.6 dB  |
| Peaking | 9289 Hz  | 3.04 | -7.0 dB |
| Peaking | 10535 Hz | 1.11 | 3.8 dB  |

### Fixed Band EQs
In case of using fixed band (also called graphic) equalizer, apply preamp of **-7.7dB**
(if available) and set gains manually with these parameters.

| Type    | Fc       |    Q | Gain    |
|:--------|:---------|:-----|:--------|
| Peaking | 31 Hz    | 1.41 | -0.5 dB |
| Peaking | 62 Hz    | 1.41 | -4.1 dB |
| Peaking | 125 Hz   | 1.41 | -2.0 dB |
| Peaking | 250 Hz   | 1.41 | 4.3 dB  |
| Peaking | 500 Hz   | 1.41 | -1.8 dB |
| Peaking | 1000 Hz  | 1.41 | -2.8 dB |
| Peaking | 2000 Hz  | 1.41 | -4.0 dB |
| Peaking | 4000 Hz  | 1.41 | 8.4 dB  |
| Peaking | 8000 Hz  | 1.41 | -2.9 dB |
| Peaking | 16000 Hz | 1.41 | 0.0 dB  |

### Graphs
![](https://raw.githubusercontent.com/jaakkopasanen/AutoEq/master/results/innerfidelity/sbaf-serious/Bang%20&%20Olufsen%20Beoplay%20H6%202nd%20Gen/Bang%20&%20Olufsen%20Beoplay%20H6%202nd%20Gen.png)

url: https://raw.githubusercontent.com/liqi1982/AutoEq/24d82474d92a53ac70b5f20a8ab4ecf71539598f/results/innerfidelity/sbaf-serious/Bang & Olufsen Beoplay H6 2nd Gen/README.md

gha_license_id: MIT


text:
## Unix philosophy
One word that can subsume the word "Unix" for this Information era - could be the word "simplicity". The main motivation for implementing Unix ([Unics](http://www.youtube.com/watch?v=7FjX7r5icV8)) was to make less sophisticated operating system and to incorporate following ideas.

>Driving idea of Unix

*  Portable: OS up to this point were wedded to the computer used

*  Mutli-tasking, multi-user
*  Simple and light-weight OS (Kernel)
*  Use of flat plain text-files
*  Hierarchical file system
*  Large number of software tools


text:
---
layout: post
title: Walnut Pie Crust
image:
  teaser: (720x100)
---

Instead of flour and sugar, this recipe leverages the natural sweetnessa and fragrance of toasted nuts as a pie/tart curst.

![Pie Crust][1]

This will go great with any pie/tart filling, for chocolate, cream, etc.

### Ingredients
- 1 1/4 cup walnut
- 2 dates pitted, chopped
- 1 tbsp butter
- 1/2 tsp baking soda
- pinch of salt

### Instructions
1. Preheat over 350 F.
1. In a processor, process walnut, dates, baking soda and salt.
1. Add butter and pulse processor until well blended.
1. Shape nut mixture on 2 small tart pan.
1. Bake for 15 min (with a pan on the bottom to prevent bottom from burning).
1. Wait until pie crust cool before carefully removing from pan.

[1]:

gha_language: CSS

gha_license_id: NOASSERTION


text:
# Inject SVG Code
Inject SVG Code is a simple independent Javascript function to inject svg code to html where svg images use with image tag. It's main use when you want to keep your code simple in your original html file and want to play with svg elements. It's simply remove the image tag ('img') having source file as svg and copy the whole svg file to it's place. Perfact examples - if you want to change and svg image element on runtime, if you want to apply css/js on svg elements or, if you want to animate svg element using css/js with proper control.

## Getting Started
To use Inject SVG simply add 'injectsvg.min.js' script from distribution directory to your project, then add a class "injectsvg" to your image tag. Ensure, you have added the script to the body of html. Link to instation [instruction](https://jaberibnemahboob.github.io/injectsvg/).
```
<img class="injectsvg" src="images/drivingcar.svg" alt="SVG file"/>

<script src="dist/js/injectsvg.min.js"></script>
```

## Examples 1 - Simple CSS styling
This example how easy to apply css rule on the svg element after the script is properly installed. Link to this example [here](https://jaberibnemahboob.github.io/injectsvg/index.html).
```
<img class="injectsvg" src="images/drivingcar.svg" alt="SVG file"/>

<script src="dist/js/injectsvg.min.js"></script>
```
This style will change the color of svg visual element. Make sure, you have defined svg elements using classes/ids like this:
`<style type="text/css">
    .wheel{fill:#FF0000;}
    .topRailing{fill:#999999;}
    .carBody{fill:#990000;}
</style>`

## Examples 2 - CSS Animation with JS click event
This is an advance example with animation applied on svg element while using the svg with img tag [here](https://jaberibnemahboob.github.io/injectsvg/anim.html).
```
<img class="injectsvg" src="images/drivingcar.svg" alt="SVG file"/>
```

## License
The code is available under the [MIT License](LICENSE).

repository: jaberibnemahboob/injectsvg

repo_name: jaberibnemahboob/injectsvg


text:
# @ts-app/graphql-todo

This project contains tutorial source codes for [@ts-app/graphql](https://github.com/ts-app/ts-app/blob/master/packages/graphql/docs/tutorial.md) and [@ts-app/security](https://github.com/ts-app/ts-app/blob/master/packages/security/docs/tutorial.md).

## Pre-requisites

* MongoDB started (i.e. mongodb://localhost:27017 accessible).
* Node v8

## Running

To run this demo, clone the repository and run these commands:

```
npm install
npm start

# The GraphQL server should be running. These URLs are available:
Endpoint : http://localhost:3000/graphql
UI       : http://localhost:3000/graphql-ui
Diagrams : http://localhost:3000/graphql-diagram/Query
Diagrams : http://localhost:3000/graphql-diagram/Mutation

```

repository: ts-app/graphql-todo

gha_language: TypeScript

repo_name: ts-app/graphql-todo


text:
# Sitemap - plus extensions

This package builds XML and text sitemaps. Sitemap indexes are still in the works, but are currently not implemented.

## Package Installation

Add the following line to your composer.json file:

```javascript
"kalley/sitemap-plus": "dev-master"
```

or run `composer require kalley/sitemap-plus:dev-master` from the command line

Add this line of code to the ```providers``` array located in your ```app/config/app.php``` file:
```php
'Kalley\SitemapPlus\SitemapPlusServiceProvider',
```

### Configuration

coming soon...

## Example

```php
Route::get('sitemap{ext?}', function($ext = '.xml') {
  return App::make('sitemap-plus')
    ->addUrl(URL::to('/'), '2014-09-09', null, '1.0', function($url) {
      $url->isMobile(true)
        ->addVideo('http://thumbnail', 'Sample video', '', null, 'http://playerloc', function($video) {
          $video->family_friendly = 'yes';
          $video->addPrice('20.00', 'USD')
            ->addPrice('25.00', 'EUR', function($price) {
              $price->resolution = 'HD';
            });
        })
        ->addImage('http://location');
    })
    ->addUrl(URL::to('about'))
    ->render($ext);
})
  ->where(['ext' => '\.(txt|xml)']);
```

For full API, see the wiki

## Support

Bugs and feature request are tracked on [GitHub](https://github.com/kalley/sitemap-plus/issues)

## License

This package is released under the MIT License.

repository: kalley/sitemap-plus

repo_name: kalley/sitemap-plus


text:
![how to make a chat app with flutter by theindianappguy](https://user-images.githubusercontent.com/55942632/81176283-938adc80-8fc2-11ea-8d59-7392205a1ed0.png)

Installation

```
flutter pub get
```
Usage

```
flutter run
```

### Learn

About Course : We will build Fully Functioning Chat App with Flutter & Firebase in 5 hours  the course is divided into 4 Parts, Everything is explained with single prerequisite of having flutter installed and run at least the sample app that's all

Full PlayList : https://www.youtube.com/playlist?list=PLBxWkM8PLHcr2vkdY2n9rIcxjZ9Th3Us7

📕 Things covered in this Series:
• Firebase Auth :  Sign in, Sign up and Sign out
• Firebase Firestore : Upload & Retrieve data stored in Cloud Firestore
• Perform simple and compound queries in Cloud Firestore
• Building Complexe UI
• Shared Preference to keep user logged in, Create chat room ( with username) & Send message ( by username)
• Using Stream & Stream builder

### Created & Maintained By

[Sanskar Tiwari](https://github.com/theindianappguy) ([@theindianappguy](https://twitter.com/Theindianappguy)) ([YouTube](https://www.youtube.com/c/SanskarTiwari))

> If you found this project helpful or you learned something from the source code and want to thank me, consider buying me a cup of :coffee:
>
> - [PayPal](https://paypal.me/iamsanskartiwari)

> You can also nominate me for Github Star developer program
> https://stars.github.com/nominate

### License

    Copyright 2020 Sanskar Tiwari

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.

## Getting Started

This project is a starting point for a Flutter application.

A few resources to get you started if this is your first Flutter project:

- [Lab: Write your first Flutter app](https://flutter.dev/docs/get-started/codelab)
- [Cookbook: Useful Flutter samples](https://flutter.dev/docs/cookbook)

For help getting started with Flutter, view our
[online documentation](https://flutter.dev/docs), which offers tutorials,
samples, guidance on mobile development, and a full API reference.
# chatroom

repository: nicoyip/chatroom

repo_name: nicoyip/chatroom


text:
# MBTIProject-CPlusPlusLanguage
A console application which can define different personality based on Myers–Briggs Type Indicator (MBTI)

# Purpose
This project was created for my Fundamentals of Programming Course that uses C++ as the Main Language.

# Developers
> Project Leader:
- Zian Jolo M. Catacutan
> Members:
- Algen Malazarte
- Kirk Jabagat
- John Paul Cervantes
- Hannah Mae Dela Cruz

# References
> The content of this test comes from:
- http://www.thepersonalitypage.com
- and was written by Robert Heyward.
> Other Source:
- https://www.google.com/amp/s/www.teamtechnology.co.uk/amp/tt/t-articl/mb-simpl.htm


text:
#### Parser Content
```Java
{
Name = q-gemalto-auth-failed
  Vendor = Gemalto
  Product = Gemalto MFA
  Lms = QRadar
  DataType = "authentication-failed"
  TimeFormat = "MM/d/yyyy H:mm:ss a"
  Conditions = [ """ resulting in AUTH_FAILURE. """ ]
  Fields = [
    """""<\d+>\w+\s+\d+:\d+:\d+\s+({host}\S+)""",
    """At\s+({time}\d+/\d+/\d\d\d\d \d+:\d+:\d+ (am|AM|PM|pm)),\s*({user}[^\s\(]+)\S*\s+from\s+({src_ip}[a-fA-F\d.:]+)\s+did\s+({action}\S+)""",
    """using\s+({auth_method}\S+)""",
    """resulting in ({outcome}AUTH_FAILURE)\.(\s*({failure_reason}.+?))?\s*""""",
  ]
}
```

repository: Shubham-goel-Exa/Content-Doc

repo_name: Shubham-goel-Exa/Content-Doc


text:
<!--
   - SPDX-FileCopyrightText: 2021 Oxhead Alpha
   - SPDX-License-Identifier: LicenseRef-MIT-OA
   -->
# Brew tap for macOS

If you're using macOS and `brew`, you can install Octez binaries from the taps provided
by this repository. There are two taps: one for the latest stable release of Octez and
one for the latest release candidate of Octez.

In order to use latest stable version run the following:
```
brew tap serokell/tezos-packaging-stable https://github.com/serokell/tezos-packaging-stable.git
```

In order to use the latest release candidate version run the following:
```
brew tap serokell/tezos-packaging-rc https://github.com/serokell/tezos-packaging-rc.git
```

Once the desired tap is selected, you can install the chosen package, e.g.:
```
brew install tezos-client
```

For faster formulae installation we provide prebuilt bottles for some macOS versions
in our releases, see [our support policy](./support-policy.md#macos-brew-formulae)
for more information.

## Launchd background services on macOS.

IMPORTANT: All provided `launchd` services are run as a user agents, thus they're stopped after the logout.

`tezos-accuser-<proto>`, `tezos-baker-<proto>` formulas
provide backround services for running the corresponding daemons.

Since `tezos-node` and `tezos-signer` need multiple services they are provided
in dedicated meta-formulas. These formulas don't install any binaries and only add
background services.

Formulae with `tezos-node` background services are, for example:
* `tezos-node-mainnet`
* `tezos-node-ghostnet`

The formulae with `tezos-signer` background services are instead:
* `tezos-signer-http`
* `tezos-signer-https`
* `tesos-signer-tcp`
* `tezos-signer-unix`

To start the service: `brew services start <formula>`.

To stop the service: `brew services stop <formula>`.

All of the brew services have various configurable env variables. These variables
can be changed in the corresponding `/usr/local/Cellar/tezos-signer-tcp/<version>/homebrew.mxcl.<formula>.plist`.
Once the configuration is updated, you should restart the service:
`brew services restart <formula>`.

## Building brew bottles

In order to build bottles with Tezos binaries run the [`build-one-bottle.sh`](../scripts/build-one-bottle.sh)
script with the formula that you want to build. For example:
```
./scripts/build-one-bottle.sh tezos-client
```

Note that several formulae have `tezos-sapling-params` has a dependency, so you
might need to run:
```
brew install --formula ./Formula/tezos-sapling-params.rb
```
first.

Building many of these might take a while, because builds don't share common parts
and for each binary the dependencies are compiled from scratch.
Once the bottles are built, the corresponding sections in the formulae should be updated.
Also, bottles should be uploaded to the release artifacts.

repository: serokell/tezos-packaging

gha_language: Python

repo_name: serokell/tezos-packaging


text:
# benchmark-python-big-files

Tests over differents python implementations with pandas to measure performance over big files processing

First file used for benchmark: http://stat-computing.org/dataexpo/2009/the-data.html (2008.csv)

Added Erlang module for the test.
Open an Erlang shell, compile the module and run with parser:parser().


text:
[Link to original README](https://github.com/chen-xanadu/gloo/blob/master/README_GLOO.md)

Added grid-based all-reduce implementation:
- [Fault-tolerant version](https://github.com/chen-xanadu/gloo/blob/master/gloo/allreduce_grid_ft.h)
- [Non fault-tolerant version](https://github.com/chen-xanadu/gloo/blob/master/gloo/allreduce_grid.h)

Example Script:
- [local_9.sh](https://github.com/chen-xanadu/gloo/blob/master/script/local_9.sh): launch 9 local processes, inject failure in rank-0 process

repository: chen-xanadu/gloo

repo_name: chen-xanadu/gloo


text:
`Card` provides a `div` element with card styling. You can pass in children, and add attributes to the `div` element by passing them as props.

```js
<Card className="errorCard">
  <h3>Something went wrong.</h3>
  <p>Please try again.</p>
</Card>
```

repository: qantasairways/runway

gha_language: JavaScript

repo_name: qantasairways/runway


text:
---
layout: post
title:  "Managing Secrets with Vault and Consul (Part II - Secrets management workflow)"
date:   2016-05-13 21:25:00
categories: Encryption Vault Consul
---

In [Part I]({% post_url 2016-05-01-secrets-vault-consul %}), we got an overview of Vault and how it might help us in managing various secrets. To better understand it, let us circle back to our 3-tier architecture again. Assume that the web app needs access to SQS and also the database (MySQL, PostgresSQL, MongoDB etc.).

If your web app is written in Flask, for e.g., you might end up putting AWS access keys in config.py or in environment or under ~/.aws/credentials - in clear. Needless to say, that is exactly what we're trying to prevent. Instead, we will have the Flask app read the secrets from Vault. This means that the secrets (AWS access keys and DB credentials) reside unencrypted only in memory. But to access Vault, the app still needs some sort of auth mechanism. In this post, we present a workflow that is designed to accommodate such a requirement in a relatively safe manner. There are three features of Vault, that we will consider:

- [Generic Secrets Backend] [1]
- [Cubbyhole Secrets Backend] [3]
- [AWS Secrets Backend] [2]

## Secret Mounts
Generic secrets backend is the default secrets backend for Vault. If you already went through the [various secret backends] [3] of Vault, you might notice that there is already a backend for MySQL, ProstgresSQL and Cassandra. And in fact, if you do use any of those, you should use those backends. But for this exercise, let us assume that you will manually create database user and password with appropriate privileges. This is to showcase the most generic solution possible via Vault. Apart from username and passwords, you could use the generic backend to store any arbitrary secret.

If you're unfamiliar with specifics of Vault set up and operations, I urge you to read either the documentation of Vault or go through Part III, which will cover the basic operations with Vault and Consul.

Let us assume you already created a generic secrets mount called "config". The mount point for this backend will always be "config/".  Similarly, let us assume that you also created a mount for AWS secrets backend and Cubbyhole. You may verify the mounts by using Vault CLI:

```bash
$ vault mounts
Path        Type       Default TTL  Max TTL  Description
aws/        aws        system       system
cubbyhole/  cubbyhole  n/a          n/a      per-token secret storage
sys/        system     n/a          n/a      system endpoints used for control, policy and debugging
config/     generic    system       system
```

The mounts will be used in our workflow for managing secrets.

## Workflow to access DB credentials
![Secrets Management Workflow](/assets/images/secrets-mgt-workflow.svg){:class="img-responsive"}

### APP ID and User ID management
The secrets are provided by Vault, and our web app will need a mechanism to access those secrets in Vault. Vault addresses this via [Auth backends] [4]. As these auth activities are machine based, an authentication backend that is more suitable for this scenario is [App ID] [5]. With App-ID auth mechanism, you will need two relatively difficult to guess secrets. For our use case, let us say we pick the following for those auth secrets:
- **For App ID**, we pick randomly generated UUID. It will be generated by some offline config management system like Ansible, Chef etc. This ensures that web app has no real control over APP ID itself and we can frequently rotate it.
- **For User ID**, let us pick the sha1sum of the mac address of eth0, of the instance where the web app is running. This will have to be calculated by the web app as well as our Ansible automation. Let us say if the mac address was "11:ff:30:d6:ba:5f", sha1sum would be: 256e73e33e468e1a679edc9e5647594b789224e5.

### Manage access to APP ID and User ID with Cubbyhole
The generated App ID will be mapped to the User ID of each instance we deploy in production. That means there will be as many mappings for that one App ID as there are instances provisioned. If you want to be even more paranoid, you could generate APP ID per instance. Using both the App ID and the User ID, the web App will be able to authenticate with Vault and then access all the config secrets. This "access" will be controlled by our policy.

Since User ID is calculated by web App at run time, the other piece it needs to know is App ID itself. Writing that information in a file (on the app server) does not increase the security posture by that much. For one, if the instance is compromised, the attacker has all the information he needs to access your secrets. In most cases, this is the weakest link in your secrets management process. To address this problem, we force the web App to fetch App ID itself from Vault. And this is where we employ the Cubbyhole secret backend of Vault. A unique feature of cubbyhole is that every token gets its own secure enclave,  and no other token (including root token) can access it.

If you're already familiar with "num_uses" option of tokens in Vault, it becomes a very convenient and required tool for our workflow. The Ansible automation responsible for generating App ID for a tenant, also generates a "temporary" token with num_uses set to something small, which we will elaborate further. The automation will use that token to write the App ID to the temporary token's cubbyhole and thus, only this temporary token can read that App ID. The automation then copies the temporary token to the app servers and restarts web app.

 All these steps exhaust the total number of uses allowed for the temporary token. To recap, following are the "uses" of the temporary token:
- One write operation to the cubbyhole (automation)
- One read operation to verify the cubbyhole content (automation)
- One auth to cubby hole by the app server
- One read by app server, which get the APP ID.

Once the "uses" are exhausted, Vault automatically revokes the token and no one can read the App ID at that path any more. To summarize, here is what the workflow achieves:

- Keeping secrets a secret
- Relatively secure way to access the store where the secrets are stored
- Frequent (or rather aggressive) rotation of authentication keys
- Supports end-to-end automation of secure access to secrets.

[1]: https://www.vaultproject.io/docs/secrets/generic/index.html
[2]: https://www.vaultproject.io/docs/secrets/aws/index.html
[3]: https://www.vaultproject.io/docs/secrets/cubbyhole/index.html
[4]: https://www.vaultproject.io/docs/auth/index.html
[5]: https://www.vaultproject.io/docs/auth/app-id.html


text:
# RayCastingBattle
RayCasting FPS in C++

# Installation

## OS X

```
mkdir build-xc && cd build-xc
cmake .. -G Xcode
open RayCastingBattle.xcodeproj
```
(UNIX method is also working (see below) if you don't [need|want] to use Xcode)

## Windows

1. Create folder build-vs
2. Open cmake-gui
3. Source Folder /path/to/project
4. Build Folder /path/to/project/build-vs
5. Open ./build-vs/RayCastingBattle.sln

## UNIX

```
mkdir build-unix && cd build-unix
cmake ..
make
```

repository: LeNiglo/RayCastingBattle

repo_name: LeNiglo/RayCastingBattle


text:
# Cyanodontia spathulata Hjortstam, 1987 SPECIES

#### Status
ACCEPTED

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

#### Published in
Mycotaxon 28(1): 23 (1987)

#### Original name
Cyanodontia spathulata Hjortstam, 1987

### Remarks
null


text:
# Capistrano::Gcp::Autoscaling

We were inspired by https://github.com/lserman/capistrano-elbas.
The gem helps deploy code to the all instances of the provided instance group.

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'capistrano-gcp-autoscaling'
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install capistrano-gcp-autoscaling

Add this line to Capfile

```ruby
require 'capistrano/gcp/autoscaling'
```

## Configuration

The gem uses a service account to get an access to GCP.
Read the documentation (https://cloud.google.com/iam/docs/creating-managing-service-accounts) if you don't know how to create it.

```ruby
set :gcp_project_id, nil
set :gcp_region, nil
set :gcp_zone, nil
set :gcp_scope, 'https://www.googleapis.com/auth/compute'
set :gcp_private_key, ENV['GCP_PRIVATE_KEY']
set :gcp_client_email, ENV['GCP_CLIENT_EMAIL']
```

## Usage

To provide an instance group, go to deploy/<stage>.rb and instead of server write the next line:

```ruby
instance_group_manager 'my-instance-group-manager1', user: 'apps', roles: %i(app web db)

instance_group_manager 'my-instance-group-manager2' do |_instance, index|
  index.zero? ? { user: 'apps', roles: %i(app web db) } : { user: 'apps', roles: %i(app web) }
end

instance_group 'my-instance-group1', user: 'apps', roles: %i(app web db)

instance_group 'my-instance-group2' do |_instance, index|
  index.zero? ? { user: 'apps', roles: %i(app web db) } : { user: 'apps', roles: %i(app web) }
end
```

## Development

After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).

## Contributing

Bug reports and pull requests are welcome on GitHub at https://github.com/a3.vorobyov/capistrano-gcp-autoscaling.

## License

The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

gha_language: Ruby


text:
# Project Name
Appt_On_Ice

## Project Description
web application for reserving time with ice skating and hockey instructors
## Team
Chester Moon
Jeff Morrow
Luis Sandoval
## Links

[Project Github Repo](https://github.com/MastadonRising/Aptt_on_Ice)

[Project Task board on github or trello](https://github.com/MastadonRising/Aptt_on_Ice/projects/1)

license: Unlicense

gha_license_id: Unlicense


text:
# Data Schema

The data schema is very lenient, and relies primarily on letting the front-end
do the mutation of data, and then registering validators to ensure that the
    internal state is not compromised when loading in the new data.

The data is handled by the `/data` API routes, described below, which are
responsible for receiving data requests from clients, filtering them based on
their access level, and serving out the data subsets.  They also ensure that the
data passed up is indeed a valid data state, and load it into the database.

## The `/data` API Routes

### GET `/data`
Returns the global dataset, filtered by the JWT auth level.

### POST `/data`
Updates the global dataset, filtered by the JWT auth level.

### GET `/data/hash`
Returns the hashed dataset, so that clients can decide whether to do a full data
refresh.

### GET `/data/event/:eventID`
Returns the dataset for a single event, filtered by the JWT auth level.

### POST `/data/event/:eventID`
Update the dataset for a single event, filtered by the JWT auth level.

### GET `/data/event/:eventID/hash`
Returns the hash for a single event's dataset, filtered by the JWT auth level.

## The `data` Client Side Library
The `data` client side library should be used in order to wrap API requests to
the server, as it handles things like caching and passively checking for data
updates.  It should check data isn't stale every time we sync up the data and
once every 2 seconds or so.

It exposes the following method:

### `data.init(updateUI, getToken))`
- Brief: Initialize the data library, with functions to update the UI, and to
  get the appropriate JWT to sign requests with.
- Param: `updateUI` Called whenever we prompt a UI update (on `data.sync` or new
  data.
- Param: `getToken` Called when we need a new JWT.
- Returns: `None`

### `data.sync`
- Brief: Pushes up a change in the data model.
- Param: `None`
- Returns: A Promise that resolves when the data model has been successfully
  synced up to the cloud.

  Should validate the data model, push it to the server, then pull down clean
  data and prompt a data refresh if necessary.

repository: ScottyLabs/events

repo_name: ScottyLabs/events


text:
---
title: Lesson 4
metadata:
    description: Sabbath School Lesson. Religoius Liberty and Health and Temperance. Lesson 4 - An Epoch of Freedom January 28, 1905.
    keywords: Sabbath School Lesson, The Bible and Liberty, Religious Liberty, Freedom of Consience, debt bondage
    author: Brian Onang'o
TOC: false
---

#### Lesson 4 —  An Epoch of Freedom

JANUARY 28, 1905.

>> Note.—This lesson is devoted largely to a consideration of religious liberty from the standpoint of the Constitution of the United States. We suggest to those using the lessons outside of the United States that, where thought necessary, the lesson be adapted as seems best.

## Questions

1. In what words did Christ draw a clear distinction between religion and civil government? Matt. 22:21. What question drew out this answer ? Matt. 22 :15-21. Note 1.
2. What nation in its constitution adopted the principle here laid down ? — The United States.
3. What statements in the Constitution of the. United States show that this government claims no jurisdiction over religious matters? Note 2.
4. What further shows that this government was established upon a new order of things ? Note 3.
5. What great declaration had been made to all the world by the people of this country, which laid the foundation for all this ? After the introduction, what are the opening words of this declaration ? Note 4.
6. What prophecy indicates that this nation will yet become a persecuting power ? Rev. 13 :11-17.
7. How will this affect other nations? Note 5.
8. What relic of a union of church and state has been retained by most of the states composing the United States ?—Sunday laws.
9. For how long a time did the Congress of the United States refuse to pass a Sunday law ?—From 1789 to 1892, or for 103 years.
10."Mention some attempts which have been made to secure national Sunday legislation in the United States, and thus get this government to commit itself to a course of religious legislation. Note 6.
11. What are the names of some of the organizations
which have been working to this end? Note 7.
12. What will the success of their efforts result in forming ? Rev. 13:14.
13. What terrible warning is given against this work ?
Rev. 14:9-12.
14. Through what means were church and state united
in the fourth and fifth centuries ? How are they being
united in the United States to-day?
15. What is "the very message for this time" ? Note 8.
16. Who only has liberty? John 8:34-36.

## Notes

1. Seeking to entangle Christ in His talk, the Pharisees
put to Him what, in logic, is called a dilemma,—a proposition or argument with two or more alternatives, either of
which is equally against the opponent. So the Pharisees
reasoned that, if Christ should say, "Yes, it is lawful to
pay tribute to Cmsar," He would offend the whole Jewish
nation, and the Sanhedrin would therefore condemn Him to
death. If He should say, "No, it is not lawful," then He
would be opposing Caesar, and the Roman power would condemn Him to death. In either case it meant death to Him.
But His answer to render to God and to Caesar each their
own, while it evaded a direct "Yes"• or "No," was so just
and reasonable that His enemies were completely confounded
and put to silence. This has been called "the wisest answer
ever given to a perplexed question." And this was the first
enunciation to the world of the great principle of a separation of religion and civil government. In all ages idolatrous
and pagan nations have regarded religion and government
as one and inseparable.
2. Article VI of the Constitution says: "No religious test
shall ever be required as a qualification to any office or
public trust under the United States." And the First Amendment says: "Congress shall make no law respecting an establishment of religion, or prohibiting the free exercise thereof." The Fourteenth Amendment says: "No state shall make
or enforce any law which shall abridge the privileges or
immunities of citizens of the United States; nor shall any
state deprive any person of life, liberty, or property without
due process of law, nor deny to any person within its jurisdiction the equal protection of the laws."
3. On the reverse side of the great seal of the United States
is a Latin inscription reading, "Novos Ordo Seculorum," which
means "A new order of things."
4. "We hold these truths to be self-evident, that all men
are created equal; that they are endowed by their Creator
with certain unalienable rights; that among these are life,
liberty, and the pursuit of happiness. That to secure these
rights, governments are instituted among men."—Declaration
of Independence.
5. "As America, the land of religious liberty, shall unite
with the Papacy in forcing the conscience and compelling
men to honor the false Sabbath, the people of every country
on the globe will be led to follow her example." ,"Foreign
nations will follow the example of the United States. Though
she leads out, yet the same crisis will come upon our people
in all parts of the world."—Testimonies, Vol. VI, pages 18, 395.
6. The first attempts to induce Congress to pass a Sunday
law were made in 1828 and 1829 over the question of the
transportation of the mails and the closing of post-offices on
Sunday. The next was in 1888, when the Blair National Sunday Rest Bill was introduced. Then came the Breckenridge
Sunday Bill for the District of Columbia, in 1890. All these
in turn were defeated in 1892. But, through threats on the
part of certain church leaders, Congress was finally induced
to pass a measure for the closing of the World's Fair at
Chicago, in 1893, on Sunday. In 1901 it passed another like
measure for the closing of the St. Louis fair, in 1904, on
Sunday. April 6, 1904, another bill for Sunday closing in
the District of Columbia passed the House of Representatives, but was not brought before the Senate before Congress
adjourned, thus leaving the bill still pending.
7. The National Reform Association was organized at
Xenia, Ohio, in 1863. Its office is located at 209 Ninth Street,
Pittsburg, Pa. The American Sabbath Union was organized
at Washington, D. C., Dec. 12, 1888. Its office address is 205 Broadway, New York. The International Reform Bureau,
styling itself "the first 'Christian lobby' established at our
national capital to speak to government in behalf of all denominations," was organized by Mr. W. F. Crafts, in 1895,
with headquarters at 103 Maryland Avenue, N. E., Washington, D. C. The chief concern of all these is to secure state,
national, and world-wide Sunday legislation, and the universal
enforcement of Sunday observance by law.
8. In 1889 this message came to us: "We as a people have
not accomplished the work which God has committed to us.
We are not ready for the issue to which the enforcement of
the Sunday law will bring us. It is our duty, as we see the
signs of approaching peril, to arouse to action. . . . The
peculiar wont of the third angel has not been seen in its importance. God meant that His people should be far in advance of the position which they occupy to-day. But now,
when the time has come for them to spring into action, they
have the preparation to make. When the National Reformers
began to urge measures to restrict religious liberty, our leading men should have been alive to the situation, and should
have labored earnestly to counteract these efforts. It is not
in the order of God that light has been kept from our people,—the very present truth •which they needed for this time.
Not all our ministers who are giving the Third Angel's Message really understand what constitutes that message. The
National Reform movement has been regarded by some as of
so little importance that they have not thought it necessary
to give much attention to it, and have even felt that, in so
doing, they would be giving time to questions distinct from
the Third Angel's Message. May the Lord forgive our brethren for thus interpreting the very message for this time."—
Testimony No. 33, pages 239-243.

repository: GospelSounders/sabbathschool

gha_language: HTML

repo_name: GospelSounders/sabbathschool


text:
# ThunderTUS PHP

Resumable file upload in PHP using tus resumable upload protocol v1.0.0.

**tus** is a HTTP based protocol for resumable file uploads. Resumable means you can carry on where you left off without re-uploading whole data again in case of any interruptions. An interruption may happen willingly if the user wants to pause, or by accident in case of a network issue or server outage.

**thunder tus** is the most reliable implementation of the tus protocol for PHP yet. Designed for **high concurrency** (real world scenarios) and integration simplicity it's **free of external dependencies** (complex caching engines etc.). It is also **PSR-7 compliant** in order to bring the tus protocol to modern PHP frameworks such as **Slim 3**.

**extensions**: building on the extensibility capabilities of the tus protocol, thunder tus also includes two new extensions:

- **CrossCheck**: final checksum of the uploaded files to ensure maximum reliability;
- **Express**: tus uploads with a single HTTP call - making tus better suited for mobile contexts and other environments where performance is a priority.

## Installation

Pull the package via composer.
```shell
$ composer require TCB13/thunder-tus-php
```

## Basic Usage

Use composer to install `tcb13/thunder-tus-php` and some other packages used in the following examples:
```shell
$ composer require tcb13/thunder-tus-php psr/http-message zendframework/zend-diactoros zendframework/zend-httphandlerrunner
```
Create your `tus-server.php` file:
````php
<?php
include "vendor/autoload.php";

$request = Zend\Diactoros\ServerRequestFactory::fromGlobals();
$response = new Zend\Diactoros\Response();

$backend = new FileSystem(__DIR__ . DIRECTORY_SEPARATOR . "uploads");
$server = new ThunderTUS\Server($request, $response);
$server->setStorageBackend($backend);
$server->setApiPath("/");
$server->handle();
$response = $server->getResponse();

$emitter = new Zend\HttpHandlerRunner\Emitter\SapiEmitter();
$emitter->emit($response);
````
Create the following `.htaccess` (or equivalent) at your virtual host:
````
RewriteEngine on
RewriteBase /
RewriteRule ^(.*)$ tus-server.php [L,QSA]
````
Now you can go ahead and upload a file using the TUS client included at `examples/client-express.php`.
After the upload is finished you may retrieve the file in another script by calling:
````php
$finalStorageDirectory = "/var/www/html/uploads";
$server = new ThunderTUS\Server();
$status = $server->completeAndFetch($filename, $finalStorageDirectory);
if (!$status) {
      throw new \Exception("Could not fetch ({$filename}) from storage backend: not found.");
}
````
The file will be moved from the temporary storage backend to the `$finalStorageDirectory` directory.

You may also retrieve the final file as a stream with `ThunderTUS\Server::completeAndStream()` or keep on the same place as the temporary parts with `ThunderTUS\Server::complete()`

## Storage Backends

In order to use **ThunderTUS you must pick a storage backend**. Those are used to temporally store the uploaded parts until the upload is completed. Storage backends come in a variety of flavours from the local filesystem to MongoBD's GridFS:

- `FileSystem`: a quick to use and understand backend for simple projects that will append uploaded parts into a file stored at the path provided on it's constructor;
- `Amazon S3`: useful in distributed scenarios (eg. your backend serves requests from multiple machines behind a load balancer), an implementation of Amazon's S3 protocol. Tested compatibility with DigitalOcean's Spaces;
- `Redis`:  also for distributed scenarios, stores uploaded parts into a Redis database;
- `MongoDB`: also for distributed scenarios, will store uploaded parts inside a MongoDB GridFS bucket.

You may also implement your own storage backend by extending the `StorageBackend` class and/or implementing the `StorageInterface` interface.

### S3 Storage Backend
````php
$server  = new \ThunderTUS\Server($request, $response);

$client = new S3Client([
    "version"     => "latest",
    "region"      => "...",
    "endpoint"    => "...",
    "credentials" => [
        "key"    => "--key--",
        "secret" => "--secret---",
    ],
]);
$backend  = new S3($client, "your-bucket", "optional-path-prefix");
$server->setStorageBackend($backend);

$server->setUploadMaxFileSize(50000);
$server->setApiPath("/tus");
$server->handle();
`````
You may later retrieve the finished upload as described above at the basic usage section.

### MongoDB Storage Backend
````php
// Connect to your MongDB
$con = new \MongoDB\Client($configs->uri, $configs->options]);
$mongodb= $con->selectDatabase($configs->db]);

// Start ThunderTUS
$server  = new \ThunderTUS\Server($request, $response);

// Load the MongoDB backend
$mongoBackend = new MongoDB($mongodb);
$server->setStorageBackend($mongoBackend );

// Set other settings and process requests
$server->setUploadMaxFileSize(50000);
$server->setApiPath("/tus");
$server->handle();

// Send the response back to the client
$response = $server->getResponse();
````
You may later retrieve the finished upload as described above at the basic usage section.

### Redis Storage Backend
````php
$server  = new \ThunderTUS\Server($request, $response);

$redisBackend = new Redis($redisClient);
$server->setStorageBackend($redisBackend);

$server->setUploadMaxFileSize(50000);
$server->setApiPath("/tus");
$server->handle();
`````
You may later retrieve the finished upload as described above at the basic usage section.

## ThunderTUS & Dependency Injection

ThunderTUS was designed to be integrated into dependency injection systems / containers.
In simple scenarios you should pass an implementation of a PSR HTTP request and response to ThunderTUS's constructor, however this is optional. Sometimes it might be desirable to be able to instantiate the `Server` in a Service Provider and provide the PSR HTTP implementations later in a controller.

Example of a **ThunderTUS service provider**:

````php
public static function register()
{
    $settings = $this->container->get("settings.tusProtocol");

    // Create the server
    $server = new Server(); // No request or response implementations passed here

    // Load the filesystem Backend
    $backend = new FileSystem($settings->path]);
    $server->setStorageBackend($backend);

    // Set TUS upload parameters
    $server->setUploadMaxFileSize((int)$settings->maxSize);
    $server->setApiPath($settings->endpoint);

    return $server;
}
````
Now the **controller that handles uploads**:

````php
public function upload()
{
    // Resolve TUS using the container
    /** @var \ThunderTUS\Server $server */
    $server = $this->container->get(\ThunderTUS\Server::class);

    // Load the request or response implementations here!
    $server->loadHTTPInterfaces($this->request, $this->response);

    // Handle the upload request
    $server->handle();

    // Send the response back to the client
    return $server->getResponse();
}
````
We've only provided the PSR HTTP request and response implementations on the controller by calling `$server->loadHTTPInterfaces(..)`.

## Client Implementations

- **PHP Client**: At the `examples` directory you may find a simple client and tus-crosscheck / tus-express examples as well;
- **JavaScript / ES6**: https://github.com/stenas/thunder-tus-js-client - a very well designed and implemented tus-crosscheck / tus-express capable client with minimal footprint.

repository: TheCoderRaman/thunder-tus-php

repo_name: TheCoderRaman/thunder-tus-php


text:
---
title: "Teaching Experience (Undergraduate Theory and Lab Courses)"
collection: teaching
type: "Undergraduate courses"
permalink: /teaching/TE1
venue: "VIT Vellore, School of Electronics Engineering"
date: 2020-01-04
location: "Vellore, TN, India."
---

My responsibilities as a Teaching and Research Assistant included helping the faculties and laboratory staff with their teaching.

### I have handled/assisted in the following courses during my Assistantship (Jan. 2016 - Jan. 2020)

1. Analog Communication Systems (Theory and Lab classes)
2. Digital Communications (Theory and Lab classes)
3. Computer Communication and Networks (Theory and Lab classes)
4. Medical Image Processing (Lab classes)

### My main responsibilities

- Assisted in formulating the syllabus along with the subject faculty.
- Created presentations and teaching plans along with the faculty incharge.
- Assisted the lab technician in instrument caliberation and maintainence.
- Helped the students during lab classes with their doubts.
- Conduct additional doubt clearing and practice sessions for the students who are lagging behind.


text:
Barkeep supports a read-only demo mode. The intention is to let people play with Barkeep without having to
log in. We use it in the demo Barkeep installation linked from getbarkeep.com. This README describes how it
works and how it's implemented.

You can set `ENABLE_READONLY_DEMO_MODE = true` in `environment.rb`. `environment.rb` is
supposed to be generated during deploy (if you're using Fezzik or Capistrano). `ENABLE_READONLY_DEMO_MODE` is
set to true for our development environments, but should be false for most production environments.

When it's true, a demo user is created in the database (see `script/create_demo_user.rb`) when
`./script/initial_app_setup.rb` gets run.

When someone navigates to Barkeep and is not logged in, we log them in as this demo user. The demo user
can create saved searches in the UI, but rather than being stored server-side as they are normally, they're
stored in a cookie.

The demo user can post comments. Those comments are not emailed, and comments by the demo user which are over
an hour old are deleted. This is to prevent us from accumulating too many comments and to avoid spam.

While "logged in" as a demo user, you can still click the "signin" link and log in as a real user using our
regular signin mechanism. This is so we can leave real comments as ourselves on that demo instance, so it has
real data.

repository: jpodeszwik/barkeep

repo_name: jpodeszwik/barkeep


text:
### web-scraping
A repository for experiments in web-scraping.

**web_scraper.py**
Usage:  web_scraper.py
The script goes to  all the websites of the form https://www.mercari.com/us/item/m{URL_NUM}/ downloads the merchandise
decription text and all the images into the folder called mercari_stuff/file_{URL_NUM}.   URL_NUM corresponds
to an time in url_id_list in the list below.

This program grabs the description and images from URL for mrechandise on www.mercari.com.
The description and the images are placed in a file named temp{FILE_NUM}.
The program also prints the current working directory and the the URLs for the images that are downloaded.
It requires two modules that are not built-in to Python: requests and beautiful soup.
Requests is used to manage the http requests. The built-in module urllib3 will handle http requests but it is difficult to use.   Beautiful soup is used to parse the html.  Both requests and beautiful soup have
excellent online documentation.   See notes below.

**Other files**
grab_urls.py
The script grab_urls.py identifies the URLs that need to be scraped.

Using this script the following ID numbers identify the URLS to be scraped.
url_id_list = ['94962627845', '28581050712', '45786125605', '59686343331', \
'58539546254', '93471915373', '86489594490', '15676221375', \
'92171004209', '59767956548', '20674928323', '89789051188', \
'61995288639', '80927475884', '96337524430', '56981262426', \
'96138398649', '60372706574', '12850962109', '20217064707', \
'11255445596', '52302814025', '32005985260', '66680840842']

get_url_text.py
Usage get_url_text.py url foldername filename
Saves the HTML for the page at url as /foldername/filename.txt in the current working directory.

erika_file
A text file with all the html on the page at the URL associated with the ID '45786125605'.
The code to generate this file is commented out in the file.

temp files
These files contain the description and images from several different pages.

Note:  robots.txt will give list of permissions.  For example: Robots.txt

**Issues**
(1)  Need to settle on a final design.
(2)  What functionality will work best.   Create scripts to access this functionality.
(3)  Need to download dates when info is posted to decide when it should be re-posted.

*********************************************************************************************
**Notes**
The idea for this code was inspired by Al Sweitgart's nice book: https://automatetheboringstuff.com/2e/chapter12/
This is a nice article on command line arguments in Python from Real Python:
https://realpython.com/python-command-line-arguments/
These two libraries have excellent documentation:
Beautiful Soup:  https://www.crummy.com/software/BeautifulSoup/bs4/doc/
Requests:  https://docs.python-requests.org/en/master/


text:
---
layout: rule
id: GORULE:0000006
title: "IEP usage is restricted to terms from the Biological Process ontology"
type: report
fail_mode: soft
status: implemented
contact<EMAIL_ADDRESS>implementations:
  - language: sparql
    code: |-
      PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
      PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
      PREFIX owl: <http://www.w3.org/2002/07/owl#>
      PREFIX RO: <http://purl.obolibrary.org/obo/RO_>
      PREFIX has_evidence: <http://purl.obolibrary.org/obo/RO_0002612>
      PREFIX enabled_by: <http://purl.obolibrary.org/obo/RO_0002333>
      PREFIX occurs_in: <http://purl.obolibrary.org/obo/BFO_0000066>
      PREFIX ECO: <http://purl.obolibrary.org/obo/ECO_>
      PREFIX IEP: <http://purl.obolibrary.org/obo/ECO_0000270>
      PREFIX GO: <http://purl.obolibrary.org/obo/GO_>
      PREFIX biological_process: <http://purl.obolibrary.org/obo/GO_0008150>
      PREFIX molecular_function: <http://purl.obolibrary.org/obo/GO_0003674>
      PREFIX namespace: <http://www.geneontology.org/formats/oboInOwl#hasOBONamespace>
      PREFIX metago: <http://model.geneontology.org/>

      SELECT DISTINCT ?ecotype ?GoTerm ?namespace
      WHERE {

        GRAPH ?g {
          ?g metago:graphType metago:gafCam .

          ?b has_evidence: ?evidence .
          ?evidence a IEP: .
          ?evidence a ?ecotype .

          # Main Triples
          # enabled_by will find innapropriate IEP in Molecular Function
          # occurs_in will find innaporpriate IEP in Cellular Component
          {
            # ?s is a MF, ?o is a GP
            ?s enabled_by: ?o .
            ?s a ?GoTerm .
          } UNION {
            # ?s is a MF, ?o is a Go Term
            ?s occurs_in: ?o .
            ?o a ?GoTerm .
          }

          ?b owl:annotatedSource ?s .
          ?b owl:annotatedTarget ?o .

          FILTER (?GoTerm != owl:NamedIndividual)
          FILTER (?ecotype != owl:NamedIndividual)
        }

        ?GoTerm namespace: ?namespace .
      }
      LIMIT 100
---
The IEP evidence code is used where process involvement is inferred from
the timing or location of expression of a gene, particularly when
comparing a gene that is not yet characterized with the timing or
location of expression of genes known to be involved in a particular
process. This type of annotation is only suitable with terms from the
Biological Process ontology.

For more information, see the [binding
guidelines](http://wiki.geneontology.org/index.php/Binding_Guidelines)
on the GO wiki.
Error report (number of errors) in [db_species]-summary.txt & owltools-check.txt (details).

repository: tutajm/go-site

repo_name: tutajm/go-site


text:
### [CVE-2007-1459](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2007-1459)
![](https://img.shields.io/static/v1?label=Product&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=n%2Fa&color=brighgreen)

### Description

Multiple PHP remote file inclusion vulnerabilities in WebCreator 0.2.6-rc3 and earlier allow remote attackers to execute arbitrary PHP code via a URL in the moddir parameter to (1) content/load.inc.php, (2) config/load.inc.php, (3) http/load.inc.php, and unspecified other files.

### POC

#### Reference
- https://www.exploit-db.com/exploits/3473

#### Github
No PoCs found on GitHub currently.

repository: trickest/cve

repo_name: trickest/cve


text:
# SWItest
Series IPython notebooks with test cases for the SWI package in MODFLOW 2005

The gridObj used in some of the scripts can by found in the SWItest/master/utils folder

## SWI 1D model
A single confined layer. GHB on the LHS representing an ocean bcn. WEL on the
RHS representing the freshwater coming from land.
One stress period is defined of perlen days and is devided into nstp time steps
and only the solution at the end of the stress period is written as output.
http://nbviewer.ipython.org/github/bdestombe/SWItest/blob/master/SWI1D/run1.ipynb

### Front reaches bottom of the aquifer
The flow is increased such, that the 50% front reaches the bottom of the confined aquifer. From this point, the SWI solution is only defined within the aquifer and therefore remains at the bottom of the aquifer.
http://nbviewer.ipython.org/github/bdestombe/SWItest/blob/master/SWI1D/reachBot.ipynb

### Not in steady state
The stress period is decreased by a factor of 250, now the model is not approaching steady state just yet, therefore the SWI solution and the Badon Ghyben Herzberg cannot be compared. We will do this anyway.
http://nbviewer.ipython.org/github/bdestombe/SWItest/blob/master/SWI1D/notSteady.ipynb

### Inclined downwards, confined
This version describes an inclined confined aquifer. Watch out! Large parts of the cells stand dry!
The SWI solution behaves like it should and doesnt crawl upward
http://nbviewer.ipython.org/github/bdestombe/SWItest/blob/master/SWI1D/inclined1conf.ipynb

### Inclined upwards, confined
This version describes an inclined confined aquifer in the opposite direction. There is no interface, everything is salt. isource is 0 for the well, so saline water is entering from the RHS.
http://nbviewer.ipython.org/github/bdestombe/SWItest/blob/master/SWI1D/inclined2conf.ipynb

### Inclined thin aquifer, zeta doesnt move up from zini
This version shows an confined aquifer, freshwater heads are around 0m. The initial zeta surface is placed a little bit above the bottom of the single aquifer. The interface is at steady state (tscale 100 changed to 1000 gave no difference). The interface is not able to move upwards, but (with playing with zini) the interface does move down if placed above the BGH solution.
http://nbviewer.ipython.org/github/bdestombe/SWItest/blob/master/SWI1D/inclined1conf_thin.ipynb

## Initially strange, Steady state again
This version shows an confined aquifer, freshwater heads are around 0m. The initial zeta surface is placed a little bit above the bottom of the single aquifer. The interface is at steady state (tscale 100 changed to 1000 gave no difference). The interface is not able to move upwards, but the interface does move down if placed above the BGH solution. Especially remarkable is the small dip in the heel.

Changing the initial zeta condition such that the first zini value (all the way on the left) reaches the top of the aquifer, lets the SWI solution follow the BGH solution. If you move this cell to the right the swi solution gets off more ( zeta is lower)

### all low zinis
All the initial zetas are placed just above the bottom
http://nbviewer.ipython.org/github/bdestombe/SWItest/blob/master/SWI1D/inclined1conf_thin2_noHigh.ipynb

### first cell zini high
http://nbviewer.ipython.org/github/bdestombe/SWItest/blob/master/SWI1D/inclined1conf_thin2_high1.ipynb

### half way the ghb cells zini high
http://nbviewer.ipython.org/github/bdestombe/SWItest/blob/master/SWI1D/inclined1conf_thin2_high2.ipynb

repository: bdestombe/SWItest

repo_name: bdestombe/SWItest


text:
---
layout: default
title: Valentin Lucet
---
# Valentin Lucet, B.Sc.(Hons)
I am a M.Sc. student in the Biology department at McGill University, supervised by Andrew Gonzalez. My research project for my master's thesis focuses on land use change, connectivity conservation and participatory modelling.

I have a special interest in computationnal applications, R package development and teaching code. See my Teaching tab for more info.

Follow me on Twitter, and read more about my research here

## R projects
### Packages
#### Maintaining

#### Contributed


text:
# Setup Quick BI with ApsaraDB for RDS {#concept_q2b_y2d_5db .concept}

This chapter shows how to configure Quick BI to render data from ApsaraDB for RDS. The following information uses a MySQL database as an example.

Assume that you already have an existing MySQL database running and data to render.

The configuration includes the following three parts.

-   Configure Quick BI
-   Create a dashboard
-   Publish a dashboard

## Prerequisites { .section}

-   Obtain MySQL credentials.

    For more information, see  [Create account and database for MySQL 5.7 High-availability Edition/5.5/5.6 instances](https://www.alibabacloud.com/help/doc-detail/26129.htm?spm=a2c63.p38356.a3.1.26854bd3feeGKO),  [Create account and database for MySQL 5.7 Basic Edition](https://www.alibabacloud.com/help/doc-detail/49015.htm?spm=a2c63.p38356.a3.2.26854bd3feeGKO), and  [Create master account](https://www.alibabacloud.com/help/doc-detail/26130.htm?spm=a2c63.p38356.a3.3.26854bd3feeGKO) .

-   Obtain a free trial Quick BI or a purchased version.

    For more information, see [Purchase, upgrade, and renew](../../../../intl.en-US/Pricing/Purchase, upgrade, and renew.md#).

## Configure Quick BI {#section_gd5_ffd_5db .section}

**Copy IP ranges from the Quick BI**

1.  Log on to the Quick BI console.
2.  Select **Workbench** \> **Data sources**, to enter the data source management page
3.  Select **Create** \> **From Cloud Database** \> **MySQL**, to create a new data source from the Cloud database.
4.  Copy IP ranges, which are displayed in the blue area. See the following figure.

    ![](http://static-aliyun-doc.oss-cn-hangzhou.aliyuncs.com/assets/img/9076/15332610681134_en-US.png)

**Obtain database endpoint from the RDS**

1.  Log on to the RDS console.
2.  Select the region where the target instance is located.
3.  Click the name of the target instance to go to the Basic Information page.

    The Internet Address is the database endpoint.

**Set whitelist on RDS**

1.  Select **Security** in the left-side navigation pane to visit the Security page.
2.  On the Whitelist Settings tab page, click **Modify**, as shown in the following figure.

    ![](http://static-aliyun-doc.oss-cn-hangzhou.aliyuncs.com/assets/img/9076/15332610691137_en-US.png)

3.  Click **Clear** to delete the IP address <IP_ADDRESS>.
4.  Click **Add a Whitelist Group** to add a new whitelist group.
5.  Enter a new group name and paste IP ranges in the whitelist area.
6.  Click **OK** to complete the whitelist settings.

    For more information, see [Set whitelist](https://www.alibabacloud.com/help/doc-detail/26198.htm?spm=a2c63.p38356.a3.5.26854bd3feeGKO) .

**Verify the data source connection**

1.  Go back to the Quick BI data sources management page.
2.  Select **Create** \> **From Cloud Database** \> **MySQL**.
3.  Enter the required information for connecting to a data source, as shown in the following figure.

    ![](http://static-aliyun-doc.oss-cn-hangzhou.aliyuncs.com/assets/img/9076/15332610691140_en-US.png)

    -   Name: The name of the data source.
    -   Database Endpoint: Enter the host name or Internet address.
    -   Port: Enter the correct port number.
    -   Database: The name of the database to be connected to.
    -   User Name: The user name of the database.
    -   Password: The password of the database.
4.  Click **Test Connection** to perform the data source connectivity test.

    If the connection goes well, a successful information is displayed.

5.  Click **Add**.  The data source is added.

    For more information, see [Create a cloud data source](intl.en-US/Quick Start/Data modeling/Data source management/Create a cloud data source.md#) and [Upload local files](intl.en-US/Quick Start/Data modeling/Data source management/Upload local files.md#).

## Create a dashboard {#section_w2n_phd_5db .section}

1.  Select a data table in the data source management page.
2.  Click **Create Dataset** next to the data table.
3.  Click **Dashboards** to enter the dashboard management page.
4.  Select **Create \> Dashboard** to enter the dashboard editing page.
5.  Select or search for the dataset that you want to analyze, as shown in following figure.

    ![](http://static-aliyun-doc.oss-cn-hangzhou.aliyuncs.com/assets/img/9076/15332610691150_en-US.png)

    For more information about dashboard basic operations, see [Dashboard basic operations](intl.en-US/Quick Start/Create a report/Dashboard basic operations/Dashboard basic operations.md#).

6.  Double-click a chart icon, for example, the line chart.   The line chart sample is displayed.
7.  Select required dimension fields and measurement fields.

    ![](http://static-aliyun-doc.oss-cn-hangzhou.aliyuncs.com/assets/img/9076/15332610691152_en-US.png)

8.  Click **Update** to complete the line chart creation.
9.  Click **Save** to save current dashboard.

## Make public a dashboard {#section_ns4_g3d_5db .section}

1.  Select a dashboard in the dashboard management page.
2.  Click **Make Public** icon next to the selected dashboard.

    ![](http://static-aliyun-doc.oss-cn-hangzhou.aliyuncs.com/assets/img/9076/15332610691158_en-US.png)

3.  Select an expiration date, and select Regenerate URL.
4.  Copy the generated URL to your browser to view the dashboard contents.

## Further reading {#section_ug2_43d_5db .section}

You can get further detailed information from the following addresses.

-   [ApsaraDB for RDS](https://www.alibabacloud.com/product/apsaradb-for-rds?spm=a2c63.p38356.a3.10.26854bd3feeGKO)
-   [Quick BI](https://www.alibabacloud.com/product/quickbi?spm=a2c63.p38356.a3.11.26854bd3feeGKO)

url: https://raw.githubusercontent.com/xiao15934831580/bi/a266cc43c3e9f5eb88bab9c630cf28e52a364687/intl.en-US/Quick Start/Setup Quick BI with ApsaraDB for RDS.md

filename: Setup Quick BI with ApsaraDB for RDS.md


text:
# box avoider

A small example game project for my game programming course

> Avoid the red boxes as long as possible to obtain the highest score.

## Running the game

+ Clone the game from github
+ Execute `npm start` in your terminal in the project's directory
+ Open http://localhost:8080 in your web browser (game is made for Chrome)

## How to play

The game features a title state, a play state, and a gameover state.

From the title state, press SPACe to start the game.

From the play state,

+ Use the UP, DOWN, LEFT and RIGHT, arrow keys to move your green box around the stage.
+ Press SPACE to pause the game
+ Hold SHIFT to activate speed boost - but beware it is limited. If your boost reaches zero,
you will have to wait a while before it can be used again.

When paused, press SPACE to resume, or ESCAPE to quit to the title state

From the gameover state, press SPACE to restart to the title state

## Licensing

```
MIT License

Copyright (c) 2017 Richard Marks

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

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

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


text:
# WindowView

**WindowView** is used to embed window style view to your project.

## Videos

## Requirements
1. iOS 10.0+
2. Xcode 9.3+
3. Swift 4.2+

## Installation

### CocoaPods

[CocoaPods](https://cocoapods.org) is a dependency manager for Cocoa projects. You can install it with the following command:

```bash
$ gem install cocoapods
```

### Integration with Xcode project

To integrate WindowView into your Xcode project using CocoaPods, specify it in your `Podfile`:

```ruby

use_frameworks!

target '<Your Target Name>' do
    pod 'WindowView'
end
```

Then, run the following command:

```bash
$ pod install
```

## Usage

### Default setup

1. Put a property of window view in your view controller
```swift

var windowView: WindowView!
```

2. Initialize window view and add it as subview to the parent view
```swift

self.windowView = WindowView(frame: self.view.frame)
self.view.addSubview(self.windowView)
```

3. Add constraints to the window view
```swift

self.windowView.leftAnchor.constraint(equalTo: self.view.leftAnchor, constant: 0).isActive = true
self.windowView.topAnchor.constraint(equalTo: self.view.topAnchor, constant: 0).isActive = true
self.windowView.rightAnchor.constraint(equalTo: self.view.rightAnchor, constant: 0).isActive = true
self.windowView.bottomAnchor.constraint(equalTo: self.view.bottomAnchor, constant: 0).isActive = true
```

4. Add animations settings to the window view
- **Note:** you can skip this section and use the default setup

```swift

let rotateIconAnimationSettings = AnimationSettings(duration: 1.5, delay: 0.5)
let openWindowAnimationSettings = AnimationSettings(duration: 1.5, delay: rotateIconAnimationSettings.fullDuration)
let closeWindowAnimationSettings = AnimationSettings(duration: 1.5, delay: 0)
let rotateIconToOriginAnimationSettings = AnimationSettings(duration: 1.5, delay: closeWindowAnimationSettings.fullDuration)

let windowAnimation = WindowAnimation(iconImagePinnedObject: .topImage, iconRotationAngle: 190, rotateIconAnimationSettings: rotateIconAnimationSettings, rotateIconToOriginAnimationSettings: rotateIconToOriginAnimationSettings, openWindowAnimationSettings: openWindowAnimationSettings, closeWindowAnimationSettings: closeWindowAnimationSettings)
```
5. Change the icon image constraints option
- **Note:** you can skip this section and use the default setup

```swift
let iconImageConstraint = IconImageConstraint(centerXConstraintConstant: 0, centerYConstraintConstant: 0, height: 128, width: 128)

let componentsConstraints = ComponentsConstraints(iconConstraints: iconImageConstraint)
```

6. Setup window view with parameters above
- You can use the defined animations form the library or use your custom animations

### Custom animation
```swift

self.windowView.setup(with: WindowViewRepresentable(firstImage: UIImage(named: "backgroundImage")!, secondImage: UIImage(named: "backgroundImage")!, iconImage: UIImage(named: "JustChatLogo")!, componentsConstraints: componentsConstraints, animation: Animations.custom(windowAnimation: windowAnimation)))
```
### Built in animations

1. Roll

```swift

self.windowView.setup(with: WindowViewRepresentable(firstImage: UIImage(named: "backgroundImage")!, secondImage: UIImage(named: "backgroundImage")!, iconImage: UIImage(named: "JustChatLogo")!, componentsConstraints: componentsConstraints, animation: Animations.roll(iconImagePinnedObject: .topImage)))

```
2. Unlock

```swift

self.windowView.setup(with: WindowViewRepresentable(firstImage: UIImage(named: "backgroundImage")!, secondImage: UIImage(named: "backgroundImage")!, iconImage: UIImage(named: "JustChatLogo")!, componentsConstraints: componentsConstraints, animation: Animations.unlock(iconImagePinnedObject: .topImage, iconRotationAngle: 190)))

```

### Setup with login view
In addition to the above customization you can add custom login view

1. Initialize login view or any view that is compatible with your project
```swift

let loginView = LoginView()
loginView.delegate = self
loginView.translatesAutoresizingMaskIntoConstraints = false
```

2. Add the login view for example to the first image view, and setup its constraints

```swift

self.windowView.firstImageView.addSubview(loginView)
loginView.topAnchor.constraint(equalTo: self.windowView.firstImageView.topAnchor, constant: 50).isActive = true
loginView.leftAnchor.constraint(equalTo: self.windowView.firstImageView.leftAnchor).isActive = true
loginView.rightAnchor.constraint(equalTo: self.windowView.firstImageView.rightAnchor).isActive = true
loginView.heightAnchor.constraint(equalToConstant: 300).isActive = true
```

## Open and close **WindowView**

1. Open
```swift
self.windowView.open()
```
2. Close
```swift
self.windowView.close()
```

**Note:** to run animation immediately once the view loaded you can call open method as show below.
```swift
override func viewDidAppear(_ animated: Bool) {
    super.viewDidAppear(animated)

    self.windowView.open()

}
```

### WindowViewDelegate
**WindowViewDelegate** contains methods that help you listening to WindowView status

methods in delegate:

```swift
func windowViewWillOpen()

func windowViewDidOpen()

func windowViewWillClose()

func windowViewDidClose()
```

## Authors

Medhat Ibsais

## License
[LICENSE](https://github.com/medhatibsais/WindowView/blob/master/LICENSE)

repository: medhatibsais/WindowView

gha_language: Swift

repo_name: medhatibsais/WindowView


text:
# MSO4SC exporter orchestrator Docker image

The exporter orchestrator will try to create and orchestrate exporters by its HTTP API. This is done through config and scripts on /app folder. To change its default configuration load /app as a volume and add your own config and script files.

### Usage
Before starting the exporter orchestrator, an MSOMonitor needs to be running and reachable. In the MSO4SC GitHub examples you can find a docker-compose example to load both of them.

The default configuration uses HOST docker to create new exporters. In order to do that, host's docker has to be mounted on the guest:
```
# docker run --rm -d -p 8079:8079 \
        -v /lib64:/lib64 -v /usr:/usr -v /lib/x86_64-linux-gnu:/lib/x86_64-linux-gnu -v /var/run/docker.sock:/var/run/docker.sock \
        mso4sc/exporter_orchestrator -monitor-host=localhost:9090
ea994b6b6ac2c73f10ca2a1150e32938031ad98a786dab5554772140c1a35c16

# docker ps -a
CONTAINER ID        IMAGE                   COMMAND                  CREATED         STATUS              PORTS                     NAMES
ea994b6b6ac2        mso4sc/exporter_orc...  "exporter_orchestr..."   7 minutes ago   Up 3 seconds        <IP_ADDRESS>:8079->8079/tcp   dreamy_spence
```

One script in docker folder helps running the image:
`run.sh` runs a new exporter orchestrator in a new container. It returns the container ID.

To build the image locally, the script `build.sh` helps doing it.


text:
Simple tool to download info about new movies on torrents (list taken from rss file).

Expose get_latest_movies() which parse rss file with newest torret movies and check the info in imdb service.
Return dict with titles as keys and dict with movie info as values.

Usage
-----
1. In your project install package: pip install movie_info_downloader
2. Usage:
```
from movie_info_downloader import get_latest_movies()

movies = get_lates_movies()
for movie in movies:
    print(movie)

>> ['Batman', 'Hobbit']
```

Installation for development
----------------------------
1. Clone repo
2. Create virtual environment via virtualenvironment: virtualenv -p <python3.5 path> env
3. Enable virtual environment: source env/bin/activate
3. Install packages: pip install -r requirements.txt
4

repository: drootnar/movie-info-downloader

repo_name: drootnar/movie-info-downloader


text:
# Terraform::AWS::LightsailKeyPair

Provides a Lightsail Key Pair, for use with Lightsail Instances. These key pairs
are separate from EC2 Key Pairs, and must be created or imported for use with
Lightsail.

~> **Note:** Lightsail is currently only supported in a limited number of AWS Regions, please see ["Regions and Availability Zones in Amazon Lightsail"](https://lightsail.aws.amazon.com/ls/docs/overview/article/understanding-regions-and-availability-zones-in-amazon-lightsail) for more details

## Properties

`Name` - (Optional) The name of the Lightsail Key Pair. If omitted, a unique
name will be generated by Terraform.

`PublicKey` - (Required) The public key material. This public key will be
imported into Lightsail.

## Return Values

### Fn::GetAtt

`Id` - The name used for this key pair.

`Arn` - The ARN of the Lightsail key pair.

`Fingerprint` - The MD5 public key fingerprint as specified in section 4 of RFC 4716.

`PublicKey` - the public key, base64 encoded.

`PrivateKey` - the private key, base64 encoded. This is only populated.

`EncryptedFingerprint` - The MD5 public key fingerprint for the encrypted.

## See Also

* [aws_lightsail_key_pair](https://www.terraform.io/docs/providers/aws/r/lightsail_key_pair.html) in the _Terraform Provider Documentation_