text:
#    The begining

I have compliled WWIV on a Raspberry Pi 4 1GB using dietpi version ARMv8 (Bullseye) image.  Here is where I can see the upgrades and changes done to the source and verify it could be done.

    https://build.wwivbbs.org/jenkins/job/wwiv/label=linux-arm64-raspbian/

The following documentation is what I used to assist in compalation.

    https://github.com/wwivbbs/wwiv#building-on-linux
    http://docs.wwivbbs.org/en/latest/install/linux/

Useless documentation as the pages go no where as the site looks broken.

    http://docs.wwivbbs.org/en/latest/linux_installation/

#    Setup system

Downloaded ISO - 64-bit

    https://downloads.raspberrypi.org/raspios_lite_arm64/images/

#    Refresh your OS

    sudo apt-get update
    sudo apt-get upgrade -y
    sudo reboot

#    Install python

    sudo apt-get install python3 python3-pip
    sudo apt-get install python python-pip

Or use python2 depending on what your distrobution expects.

    sudo apt-get install python2 python2-pip

If pip will not install for python/2 then use the below command to download to your system

    curl https://bootstrap.pypa.io/pip/2.7/get-pip.py --output get-pip.py
    sudo python2 get-pip.py

#    Install essentials

    sudo apt install -y build-essential make cmake gcc g++ git curl wget htop ninja-build neofetch default-jdk default-jre mosh screen bmon wavemon iftop ipcalc hexcurse exa hping3 arping lshw fping chkrootkit ioping trash-cli ranger mc whowatch lsof nethogs fdupes stress ccze tilde nmap original-awk gawk curl git wget zip unzip unrar-free tshark saidar xlsx2csv docx2txt pwgen libcrack2
    sudo reboot

#    Create and move to temp directory

    mkdir ~/projects
    cd ~/projects

#    Install bpytop (a much better and more colorful htop command)

    pip3 install bpytop

#    Install LSD a more colorful LS

    wget https://github.com/Peltoche/lsd/releases/download/0.20.1/lsd-musl_0.20.1_arm64.deb
    nano ~/.bashrc

Then edit alias

    ls='ls' to alias ls='lsd'

#    Install SYNTH-SCHELL a very fancy command prompt

    git clone --recursive https://github.com/andresgongora/synth-shell.git
    chmod +x synth-shell/setup.sh
    cd synth-shell
    ./setup.sh

*At the prompt please enter /I /U /N /Y /N /N /N

#    Setting up / Installing ZRAM (only needed if not using dietpi)

Remove the old dphys version

    sudo /etc/init.d/dphys-swapfile stop
    sudo apt-get remove --purge dphys-swapfile

Install zram

    sudo wget -O /usr/bin/zram.sh https://raw.githubusercontent.com/novaspirit/rpi_zram/master/zram.sh

Set autoload

    sudo nano /etc/rc.local

Add the next line before exit 0

    /usr/bin/zram.sh &

    Save with <Ctrl+X>, <Y> and <Enter>

Save with Ctrl+X, "Y" and "Enter"

    /usr/bin/zram.sh &
    sudo chmod +x /usr/bin/zram.sh
    sudo nano /usr/bin/zram.sh

Alter the limit with * 2

    mem=$(( ($totalmem / $cores)* 1024 * 2))

Save with Ctrl+X, "Y" and "Enter"

    sudo reboot

Setting up / Installing ZRAM (if using dietpi)

Now we will be editing the configuration file.

    sudo nano /boot/diepi.txt

In /boot/diepi.txt change the "1" to your desired swap file size. I used 2GB instead of auto.

    AUTO_SETUP_SWAPFILE_SIZE=2048

Then reboot

    sudo reboot

#    Install RPI monitor

     sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-key 2C0D3C0F
     sudo wget http://goo.gl/vewCLL -O /etc/apt/sources.list.d/rpimonitor.list
     sudo apt update
     sudo apt install -y rpimonitor

Use the below to stop / start / restart

    sudo service rpimonitor stop
    sudo service rpimonitor start
    sudo service rpimonitor restart
    sudo service rpimonitor status

Open a browser and go to http://<IP_ADDRESS>:8888

#  Install bat a more IDE color style cat command
   Download 64-bit

     wget https://github.com/sharkdp/bat/releases/download/v0.18.3/bat_0.18.3_arm64.deb

   Download 32-bit

     wget https://github.com/sharkdp/bat/releases/download/v0.18.3/bat_0.18.3_armhf.deb

#  Install bat

     sudo dpkg -i bat_*.deb
     rm bat*.deb
     bat /etc/profile

#    Install ps-mem a more granular way to see what apps are using your memory more usefully.

     sudo wget -O /usr/local/bin/ps_mem https://raw.githubusercontent.com/pixelb/ps_mem/master/ps_mem.py
     sudo ps_mem

#    + Setting up box64

    git clone https://github.com/ptitSeb/box64
    cd box64; mkdir build; cd build

#    Install Box64

    cmake .. -DRPI4ARM64=1 -DCMAKE_BUILD_TYPE=RelWithDebInfo
    make -j$(nproc)
    sudo make install
    sudo systemctl restart systemd-binfmt

#    Install Telet

    sudo apt install telnet telnetd
    sudo nano /etc/services

Change the following lines for telnet access

    #telnet         23/tcp
    telnet         2323/tcp

Restart

    sudo reboot

#    Install WWIV on linux

    mkdir ~/git/
    cd ~/git/
    sudo mkdir -p /opt/wwiv && sudo chown "$(id -u):$(id -g)" /opt/wwiv

#    Build from source

    git clone --recurse-submodules -j8 https://github.com/wwivbbs/wwiv.git
    cd wwiv/
    wget https://github.com/wwivbbs/wwiv/releases/download/wwiv_5.7.1/wwiv-linux-arm64-raspbian-<IP_ADDRESS>32.tar.gz
    mkdir _build
    cd _build
    ../cmake-config.sh
    cmake --build .
    cd ~/git/wwiv/
    mv README.md readme1st.txt

Moving the build from building directory to working directory

    mv ~/git/wwiv/* /opt/wwiv/

Or, copy all of the files newly built, or symlinks to them from your WWIV base install i.e. in /opt/wwiv/ (assuming the source is in $HOME/git/wwiv) now

    cd /opt/wwiv
    wget https://github.com/wwivbbs/wwiv/releases/download/wwiv_5.7.1/wwiv-linux-arm64-raspbian-<IP_ADDRESS>32.tar.gz
    ln -s $HOME/git/wwiv/builds/tools/linux/use-built-bin.sh
    export BUILT_BIN=$HOME/out/wwiv/_build/
    ./use-built-bin.sh ${BUILT_BIN} ~/git/wwiv/_build/bbs/bbs ~/git/wwiv/_build/wwivd/wwivd ~/git/wwiv/_build/wwivconfig/wwivconfig ~/git/wwiv/_build/wwivfsed/wwivfsed ~/git/wwiv/_build/wwivutil/wwivutil ~/git/wwiv/_build/network/network ~/git/wwiv/_build/network1/network1 ~/git/wwiv/_build/network2/network2 ~/git/wwiv/_build/network3/network3 ~/git/wwiv/_build/networkb/networkb ~/git/wwiv/_build/networkc/networkc ~/git/wwiv/_build/networkf/networkf ~/git/wwiv/_build/networkt/networkt

From the wwiv directory (i.e. /opt/wwiv), run sudo ./install.sh and follow the prompts.
There are many options available for install.sh, please run sudo ./install.sh  --help for the full list of options. By default the script expects the username and groupname to both be wwiv and not yet exist.

You must run this as root. The script performs the following tasks for you: creating the WWIV user and group setting up sudo access for a standard user installing the systemd service file.

    sudo ./install.sh --help
    sudo ./install.sh -n
    sudo ./install.sh

If you have any issues, check the install_date_time.log file that was created during the install.  If you still can't tell what happened, come and find us in IRC or post a message in one of the wwiv support subs.

#    After the install

Now, you may log into the new wwiv user (e.g, sudo -u wwiv -s) and run ./wwivconfig to configure the BBS. (If that first sudo command doesn't work on your system, try sudo su - wwiv -s /bin/bash)

    sudo -u wwiv -s
    ./wwivconfig

Once in the menu answer the initial question to setup the general BBS operations.

Go to option W (wwivd Configuration)

    Telnet Port: (Change to 2323)
    SSH port: (Change -1)

Add your user to the WWIV group:

    sudo usermod -a -G wwiv $USER

To ensure everything is owned properly to start:

    sudo chown -R wwiv:wwiv /opt/wwiv

Set the permission for the main folder:

    sudo chmod 2775 /opt/wwi

The chmod values are: 2=set group id, 7=rwx for owner (wwiv), 7=rwx for group (wwiv), 5=rx for world. Setting group ID (SETGID) bit (2) causes the group (wwiv) to be copied to all new files/folders created in that folder.

Use find to do the same process for all subdirectories:

    sudo find /opt/wwiv -type d -exec chmod 2775 {} +

Make sure all other files are read/write for group:

    sudo find /opt/wwiv -type f -perm 664 -exec chmod 0664 {} +
    sudo find /opt/wwiv -type f -perm 644 -exec chmod 0664 {} +
    sudo find /opt/wwiv -type f -perm 646 -exec chmod 0664 {} +
    sudo find /opt/wwiv -type f -perm 666 -exec chmod 0664 {} +

Change the umask for your users to 0002 by adding this line to the bottom of /etc/profile

    umask 0002

Now reboot the system:

    sudo reboot

If you've gotten this far, Your BBS should be up and running. Everything below this point is details about more in-depth configuration (DOORs, WWIVnet, etc) and some of the current warts that linux has that you need to be aware of. If you come across anything that is not detailed here, please let us know.

    http://docs.wwivbbs.org/en/latest/chains/tradewars2002/

For more information on WWIV confifuration options / paramaters.

    http://docs.wwivbbs.org/en/latest/cfg/wwivconfig/

#    + Errors

Here are some of the common errors I encountered why compiling:

    ../core/parser/ast.cpp:172:10: warning: enumeration value ‘number’ not handled in switch [-Wswitch]
    ../core/parser/ast.cpp:172:10: warning: enumeration value ‘error’ not handled in switch [-Wswitch]
    ../core/parser/ast.cpp: In function ‘std::unique_ptr<wwiv::core::parser::BinaryOperatorNode> wwiv::core::parser::createBinaryOperator(const wwiv::core::parser::Token&)’:
    ../core/parser/ast.cpp:183:10: warning: enumeration value ‘lparen’ not handled in switch [-Wswitch]
      183 |   switch (token.type) {
          |          ^
    ../core/parser/ast.cpp:183:10: warning: enumeration value ‘rparen’ not handled in switch [-Wswitch]
    ../core/parser/ast.cpp:183:10: warning: enumeration value ‘negate’ not handled in switch [-Wswitch]
    ../core/parser/ast.cpp:183:10: warning: enumeration value ‘semicolon’ not handled in switch [-Wswitch]


text:
# JaegerSamplingFilters

A collection of useful Jaeger filters and samplers which will allow you to easily filter your requests
based on the incoming HttpRequest object.

## Huh?

Normally in Jaeger you have the ability to use various OpenTracing Samplers to decide when to trace a span.
This might be a probability measure (trace 60% of spans), or a simple on/off. There is also an AdaptiveSampler which lets
you make a decision based on the method of the call. This often is inconsistent, and only allows filtering on the one variable.
We wanted something better.

The sampling filters here will allow you to filter traces based on anything you can find in the incoming HttpRequest object.
Want to trace based on the existance of a header? We got you. Don't want to trace web requests for HTTP requests to any route under/v2
but only between 2 and 4PM on a Tuesday - you're probably doing it wrong, but you have the power. Most of you, however, probably just want
to filter based on the incoming route. ;)

## Show Me The $%^£ Code!

Fine, so lets assume you have Jaeger setup to trace everything. Your setup in the Startup class will look a lot like:

```c#
services.AddSingleton<ITracer>(new Tracer.Builder(serviceName)
	.WithReporter(myReporter)
	  .WithSampler(new ConstSampler(true))
    .Build());
```

Now, you find that you need to expose a /metrics route for your health service to query. Great!  (This never happened to me, stop looking at me like that!)

Lets filter out the metrics endpoint then:

```c#
services.AddSingleton<ITracer>(sp => new Tracer.Builder(serviceName)
	.WithReporter(myReporter)
	  .WithSampler(new RequestFilteringSampler(new ISamplingFilter[]
	{
		new RegexSamplingFilter("/metrics", new ConstSampler(false))
	},
	defaultSampler: new ConstSampler(true)
	httpContextAccessor: sp.GetRequiredService<IHttpContextAccessor>()))
    .Build());
```

OK cool! So if we take this apart a little, we have a RequestFilteringSampler with:
- A collection of ISamplingFilters, these will be checked in turn for each incoming request;
- A RegexSamplingFilter which will match incoming '/metrics' requests, and send them to a ConstSampler(false). I.E. it won't trace them;
- A default sampler to use for everything not matched by the ISamplingFilters - in this case a ConstSampler(true);
- A context accessor, so that we can inspect the incoming request.

We can actually write this much more compactly using the defaults available:

```c#
services.AddSingleton<ITracer>(sp => new Tracer.Builder(serviceName)
	.WithReporter(myReporter)
	  .WithSampler(new RequestFilteringSampler(new ISamplingFilter[]
	{
		new RegexSamplingFilter("/metrics", false)
	},
	sp.GetRequiredService<IHttpContextAccessor>()))
    .Build());
```

This should be plenty to get you off the ground running. There will be further guides incoming on creating your own SamplingFilters
and further filters themselves. Please create an issue for problems you find, or any filters you would like to see.

license: MIT

repository: csurfleet/JaegerSamplingFilters

branch_name: refs/heads/master

extension: md

gha_language: C#

gha_license_id: MIT

license_type: permissive

repo_name: csurfleet/JaegerSamplingFilters


text:
# Basic Concepts

## Each Hero Instance Has a Unique User

- user-agent
- ip address
- audio fingerprint
- fonts
- webgl / canvas
- cookies & storage
- screen details
- 100s more

Note: IP addresses are set through upstreamProxyUrl on each Hero.

## The DOM Has Finally Been Awaited

The easiest way to explain Dynamic DOM is with some comparison examples. Let's say you want to load a URL and loop through a list of items.

### Doing It with Hero

Here's how you would do it with Hero:

```js
import Hero from '@ulixee/hero';

const { document } = hero;

const elems = document.querySelectorAll('ul');
for (const elem of await elems) {
  db.query('SELECT FROM items WHERE id=?', [elem.id]);
  // ^^ WORKS
}
```

Hero's Dynamic DOM allows you to keep all calls within your script context. It also follows the W3C spec to a T. In fact, go ahead and copy lines 3 through 7 and run paste them into your browser's DevTools. They run perfectly.

### Doing It with Puppeteer

Here's how you would do it with Puppeteer:

```js
const Puppeteer = require('puppeteer');

const selector = 'ul li';
page.evaluate(
  (selector, db) => {
    const elems = document.querySelectorAll(selector);
    for (const elem of elems) {
      db.query('SELECT FROM items WHERE id=?', [elem.id]);
      // ^^ BREAKS
    }
  },
  selector,
  db,
);
```

As you'll notice, the above example throws an error. Although you can pass arguments into a remote method, they must be serializable, which means you can only pass through simple types.

When used in a simple example as show above, Puppeteer's approach seems okay. However, the reality is, most scraper scripts are complex, and your code becomes littered with multiple contexts, adding context to an already complex environment.

## Headless Browsers Need Not Always Render

When you're trying to eke out performance, a common technique is to disable rendering various parts of a webpage. Hero allows you to [turn off](/docs/overview/configuration#blocked-resources) everything from the style and images of a page, to the javascript environment. You can even simulate making http requests from inside a loaded web page, without ever loading the page.

```js
import Hero from '@ulixee/hero';

const hero = new Hero();
await hero.configure({
  blockedResourceTypes: ['All'],
});
await hero.goto('https://ulixee.org');
// referer will be https://ulixee.org
const doc = await hero.fetch('https://ulixee.org/docs/overview/configuration');
```

## Mice and Keyboards Are Human Too

Hero drives mice and keyboards with [Human Emulators](/docs/plugins/human-emulators). Human emulators translate your clicks and moves into randomized human-like patterns that can pass bot-blocker checks.

repository: MrNiceBOT/hero

branch_name: refs/heads/main

repo_name: MrNiceBOT/hero


text:
---
layout: tutorial
title: "Basics"
section: tutorial
sort_order: 0
---
There are a few concepts to get familiar with before getting to grips with kantan.regex proper.

## Regular expression literals

First, regular expression literals: regular expressions that are validated at compile time. This is the preferred way
of creating regular expressions and will be used throughout the documentation, so it's best to get that out of the way
as soon as possible.

There are various ways of enabling the feature, the simplest and most common one being to import
[`kantan.regex.implicits._`]:

```scala mdoc:silent
import kantan.regex.implicits._
```

This will also bring kantan.regex syntax in scope though, so if you only want the literals, you can simply import
[`kantan.regex.literals._`].

This lets you create new regular expression by prefixing string literals with [`rx`]:

```scala mdoc
rx"\d+"

rx"[ -~]"
```

And, as promised, this fails *at compile time* if the regular expression is not valid:

```scala mdoc:fail
rx"[abc"
```

## Simple evaluation

Subsequent pages will get into more details, but the simplest, most idiomatic way of extracting well typed data from
strings using kantan.regex is through the [`evalRegex`] method that enriches strings (since we've imported
[`kantan.regex.implicits._`]). For example:

```scala mdoc
"123 and some text followed by 456 and then 789".evalRegex[Int](rx"\d+").foreach(println _)
```

[`kantan.regex.implicits._`]:{{ site.baseurl }}/api/kantan/regex/implicits$.html
[`kantan.regex.literals._`]:{{ site.baseurl }}/api/kantan/regex/literals/index.html
[`rx`]:{{ site.baseurl }}/api/kantan/regex/literals/RegexLiteral.html#rx(args:Any*):kantan.regex.Pattern
[`evalRegex`]:{{ site.baseurl }}/api/kantan/regex/ops/StringOps.html#evalRegex[A](p:kantan.regex.Pattern)(implicitevidence$1:kantan.regex.MatchDecoder[A]):Iterator[kantan.regex.DecodeResult[A]]

gha_language: Scala


text:
# SassC::ImportOnce
[![Gem Version][gem-badge]][gem]
[![Build status][build-badge]][build]

Changes the behavior of Sassc's @import directive to only import a file once. This is very similar to the functionality provided by https://github.com/Compass/compass/tree/master/import-once for Sass.

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'sassc-import_once', :require => 'sassc/import_once/activate'
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install sassc-import_once

## Usage

TODO: Write usage instructions here

## Contributing

1. Fork it ( https://github.com/[my-github-username]/sassc-import_once/fork )
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create a new Pull Request

[gem-badge]:      https://badge.fury.io/rb/sassc-import_once.svg
[gem]:            http://badge.fury.io/rb/sassc-import_once
[build-badge]:    https://travis-ci.org/appfolio/sassc-import_once.svg
[build]:          https://travis-ci.org/appfolio/sassc-import_once

gha_language: Ruby


text:
```
On 2016-07-27 08:34, Sandeep Dasgupta wrote:
>
> Question 1
>
> In reference to this particular paper, is variable recovery included
> in this type inference ? Or the variables (like scalar and aggregate
> variables) are already recovered before this particular type
> inference
> kicks in ? Or variable recovery is irrelevant  in the context of this
> paper,  because this paper only talks about inferring the type of
> stack offsets?

In our case, we performed variable recovery using CodeSurfer's standard
analyses first, then used Retypd to perform type inference over the
recovered variables.

Because of this two-phase approach, knowledge gained during type
inference
is not directly reflected back on the layout of memory regions (e.g.
the
stack regions or or global region).

> From the constraints generated (as given in Figure 2), it seems that
> some constraints considers the offset information of the  fields of
> a structure (w.r.t the procedure's base pointer ), which after
> solving
> is going to help in knowing the type of the those fields. But it is
> not obvious to me if this particular paper is doing any kind of
> "structure variable" recovery using those offset information ?

The flip-side to the two-phase approach is that even if CodeSurfer does
*not* determine that variable X points to region Y that has layout
{ int, char* } Retypd may still be able to figure out that X's type is
{ int, char* }*. So Retypd often figures out lots of structural
layout information beyond CodeSurfer's normal variable recovery.

> More specifically, In figure 2 of the paper, we can see the following
> constraints corresponding to instructions mov eax ,dword [edx]  and
> mov eax ,dword [edx + 4] respectively.
>
>>  τ.load.σ32@0 <: τ
>
>> τ.load.σ32@4 <: int ∧#FileDescriptor
>
> Are these constraints  also used to infer a "structure variable" with
> two fields at offset 0 and 4? Or its is used just to infer the type
> of
> the variables at offsets 0 and 4 from the base pointer of the
> procedure?

The former: even if we do not have an abstract location to represent
the points-to
target of τ, Retypd will still infer τ ~ struct T { struct T * x; int
y; } here.

> Question2
>
> This question is  related to my previous question.
>
> As you  mentioned  that you do not need any pointer analysis
> information to infer that x has a the type struct S { struct S *,
> ...}*. I believe that the way you achieve this is by adding a new
> constraint for each instruction corresponding to the access of the
> fields of x and solving them later. (Please correct me if I am wrong
> here).  If this is correct, then doesn't that mean that you  already
> have the information that x is a struct (but of course without the
> type information of its fields) before starting this type inference?

The constraints are generated only from syntactic information about the
program's instructions, so there is no need to know facts like "X is a
struct",
"Y is a pointer" etc before beginning.

Matt
```

license: NCSA

repository: mewbak/binary-decompilation

gha_license_id: NOASSERTION

repo_name: mewbak/binary-decompilation


text:
# Popular Movies - Movie Guide

This app fetches Movie Information from TMDB api. This app was built as a part of Nanodegree Project.

Optimized to run on both tablets and Phones. Can be enjoyed on both tablet and Phones.

This app is a just a simple movie guide. Users can browse the movies based on popularity, Movie Ratings and other criteria.
and they can shortlist their favourite movies. So that they can have a good collection of the movies that interests them and they desire to watch.

Put sipmply this app helps users to discover great movies that they would like to watch and enjoy.

##Screenshots :

![alt tag](https://github.com/SumeetMoray/Movie-Guide/blob/master/ScreenShotsResized/Screenshot_2016-03-09-15-08-24-r.png)

Front Screen

![alt tag](https://github.com/SumeetMoray/Movie-Guide/blob/master/ScreenShotsResized/Screenshot_2016-03-09-15-08-47-r.png)

Movie Detail Screen

![alt tag](https://github.com/SumeetMoray/Movie-Guide/blob/master/ScreenShotsResized/Screenshot_2016-03-09-15-09-31-r.png)

Tablet Landscape View

![alt tag](https://github.com/SumeetMoray/Movie-Guide/blob/master/ScreenShotsResized/Screenshot_2016-03-09-15-09-57-r.png)

Favouriting a Movie by pressing the Floating Heart Button

![alt tag](https://github.com/SumeetMoray/Movie-Guide/blob/master/ScreenShotsResized/Screenshot_2016-03-09-15-10-19-r.png)

Making a movie selection with the Spinner

##Download Link:

* [Movie-Guide] (https://raw.githubusercontent.com/SumeetMoray/Movie-Guide/master/app/app-release.apk)

##Libraries Used :

* [ButterKnife](https://github.com/JakeWharton/butterknife)
* [Retrofit](https://github.com/square/retrofit)
* [Picasso](http://square.github.io/picasso/)
* [Android Support Palette Library](http://developer.android.com/reference/android/support/v7/graphics/Palette.html)

License
--------

    Copyright 2016 Sumeet Moray.

    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.

repository: SumeetMoray/Movie-Guide

repo_name: SumeetMoray/Movie-Guide


text:
# go-reader-whosonfirst-data

Who's On First (GitHub) data support for the go-reader.Reader interface.

## Important

This package has been deprecated and will no longer be updated. It has been superseded by [whosonfirst/go-reader-findingaid](https://github.com/whosonfirst/go-reader-findingaid).

### Notes

The default behaviour for resolving a Who's On First ID to its corresponding GitHub repository is to use the [data.whosonfirst.org/findingaid](https://data.whosonfirst.org/findingaid/) lookup service. If you know the repository that all of the pathN arguments are part of you can skip the lookup service by appending the repo name as a query parameter to the `-reader-uri` argument.

For example:

```
-reader-uri whosonfirst-data://?repo=whosonfirst-data-admin-ca
```

## Tools

To build binary versions of these tools run the `cli` Makefile target. For example:

```
$> make cli
go build -mod vendor -o bin/read cmd/read/main.go
```

### read

```
$> ./bin/read -h
Read one or more Who's On First records from the whosonfirst-data GitHub organization.

Usage:
  ./bin/read [options] [path1 path2 ... pathN]

Options:
  -reader-uri string
    	A valid go-reader-whosonfirst-data URI. (default "whosonfirst-data://")

Notes:

pathN may be any valid Who's On First ID or URI that can be parsed by the
go-whosonfirst-uri package.

The default behaviour for resolving a Who's On First ID to its corresponding
GitHub repository is to use the 'data.whosonfirst.org/findingaid' lookup
service. If you know the repository that all of the pathN arguments are part of
you can skip the lookup service by appending the repo name as a query parameter
to the '-reader-uri' argument. For example: -reader-uri
'whosonfirst-data://?repo=whosonfirst-data-admin-ca'.
```

Read one or more Who's On First records from the whosonfirst-data GitHub organization.

For example:

```
$> ./bin/read 85633041 | jq '.properties["wof:name"]'
"Canada"
```

## See also

* https://github.com/whosonfirst-data
* https://github.com/go-whosonfirst-reader
* https://github.com/go-whosonfirst-reader-github
* https://github.com/go-whosonfirst-findingaid
* https://github.com/go-whosonfirst-whosonfirst-reader

repository: whosonfirst/go-whosonfirst-fetch

repo_name: whosonfirst/go-whosonfirst-fetch


text:
# WebSpell

[![Build Status](https://travis-ci.org/langalex/web_spell.svg?branch=master)](https://travis-ci.org/langalex/web_spell)

[![Ebert](https://ebertapp.io/github/langalex/web_spell.svg)](https://ebertapp.io/github/langalex/web_spell)

WebSpell is an HTTP mocking library for Elixir. It is somewhat inspired by WebMock for Ruby, but adapted to the different programming environment of Elixir.

## Motivation

When I started my first Elixir/Phoenix web app and started looking for ways to stub calls to external services, all I found was a few blog posts that told me to replace my HTTP client with a (static) module for testing like this:

```elixir
defmodule TestStub do
  def get("http://example.com/1") do
    {:ok, "resource 1"}
  end

  def get("http://example.com/2") do
    {:ok, "resource 2"}
  end
  # etc.
end
```

This way my tests wouldn't hit any real endpoints and stay fast. This approach may work for projects communicating very little with the outside world, but not for what I'm doing. What you are doing essentially is creating fixtures, i.e. some static data that all your tests depend on. As your test suite grows, you need more of them, and whenever you change one, something breaks somewhere else.

So what I needed was a way to set up stubbed web requests that were different for every test case. Say hello to WebSpell.

## Installation

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

```elixir
def deps do
  [{:web_spell, "~> 0.1.0"}]
end
```

## Usage

Please note: the examples below use the Poison library for JSON parsing/encoding.

You start with a module that calls your HTTP client of choice:

```elixir
defmodule MyWebClient do
  def get_user
    HTTPoison.get("http://example.com/user", {access_token: "123"}, {Accept: "application/json"})
  end
end
```

To start using WebSpell, make the HTTP client configurable by using a module attribute.

```elixir
# a module that uses any HTTP client to make request
defmodule MyWebClient do
  @http_client Application.get_env(:my_app, :http_client) # either an actual HTTP client module or your mock module

  def get_user
    {:ok, response} = @http_client.get("http://example.com/user", {access_token: "123"}, {Accept: "application/json"})

    Poison.Parser.parse!(response.body)
  end
end
```

For development/production environments, configure your normal client:

```elixir
# config/config.exs
use Mix.Config
import_config "#{Mix.env}.exs"

# config/prod.exs / config/dev.exs
use Mix.Config
config :my_app, http_client: HTTPoison

# config/test.exs
use Mix.Config
config :my_app, http_client: MockHTTPClient
```

And implement a mock HTTP client using WebSpell:

```elixir
defmodule MockHTTPClient do
  use WebSpell

  def get(url, query, headers) do
    response = call_stubbed_request! %WebSpell.Request{method: :get, url: url, query: query, headers: headers}
    {:ok, response.body} # emulate the behavior of your production HTTP client
  end
end
```

Finally you can start writing tests using WebSpell:

```elixir
defmodule MyWebClientTest do
  use ExUnit.Case, async: false # sorry, WebSpell can only handle one test at a time

  setup do
    MockHTTPClient.start_link()
    :ok
  end

  test "get_user returns user data" do
    MockHTTPClient.stub_request(
      %WebSpell.Request{
        method: :get,
        url: "http://example.com/user",
        query: {access_token: "123"}, # optional
        headers: {Accept: "application/json"} # optional
      },
      %WebSpell.Response{
        status_code: 200,
        body: Poison.encode!(%{"email" =><EMAIL_ADDRESS># convert to JSON
      }
    )

    user = MyWebClient.get_user

    assert user == {"email" =><EMAIL_ADDRESS>    assert MockHTTPClient.received_request(
      %WebSpell.Request{method: :get,
                        url: "http://example.com/user",
                        query: {access_token: "123"},
                        headers: {Accept: "application/json"}})
    assert MockHTTPClient.received_no_request
      (%WebSpell.Requestr{method: :get, url: "http://example.com/account"})
  end
end
```

You can also specify a a timeout to wait for a request to be made asynchronously:

```elixir
assert MockHTTPClient.received_request(
  %WebSpell.Request{method: :get,
                    url: "http://example.com/user",
                    },
                    200) # timeout in ms
```

For POST/PUT etc. you can pass in a body:

```elixir
assert MockHTTPClient.received_request(
  %WebSpell.Request{method: :post,
                    url: "http://example.com/user",
                    body: Poison.encode!(%{email: "joe@example.com"}),
                    headers: {Accept: "application/json"}})
```

## Ideas

Add support for a few popular HTTP clients and return responses matching them instead of just WebSpell.Response.


text:
Package

  A javascript package template and cli tool.

### Install

With yarn:

```
yarn global add @juliendargelos/package
```

With npm:

```
npm install -g @juliendargelos/package
```

### Usage

Create a package:

```
package [PATH]
```

If path is omitted, the package will be created in the working directory.

### Configurable template features

- [rollup](https://github.com/rollup/rollup)
    + [cmjs](https://rollupjs.org/guide/en#output-format), [es](https://rollupjs.org/guide/en#output-format), [umd](https://rollupjs.org/guide/en#output-format)
    + [rollup-plugin-terser](https://www.npmjs.com/package/rollup-plugin-terser)
    + [rollup-plugin-eslint](https://github.com/TrySound/rollup-plugin-eslint)
- [typescript](https://github.com/microsoft/TypeScript)
- [babel](https://github.com/babel/babel)
    + [babel-plugin-proposal-class-properties](https://github.com/babel/babel/tree/master/packages/babel-plugin-proposal-class-properties)
    + [babel-plugin-proposal-decorators](https://github.com/babel/babel/tree/master/packages/babel-plugin-proposal-decorators)
    + [babel-plugin-module-resolver](https://github.com/tleunen/babel-plugin-module-resolver)
- [typedoc](https://github.com/TypeStrong/typedoc)
- [jsdoc](https://github.com/jsdoc3/jsdoc)
    + [minami](https://github.com/nijikokun/minami)
    + [markdown](https://github.com/jsdoc3/jsdoc/blob/master/plugins/markdown.js)
    + [jsdoc-this-type-plugin](https://github.com/juliendargelos/jsdoc-this-type-plugin)
    + [jsdoc-inheritparams-plugin](https://github.com/juliendargelos/jsdoc-inheritparams-plugin)
- [eslint](https://github.com/eslint/eslint)
- [jest](https://github.com/facebook/jest)
    + [Codeclimate reporter](https://github.com/codeclimate/test-reporter)
- [husky](https://github.com/typicode/husky)
- [MIT Licence](https://choosealicense.com/licenses/mit/)

repository: juliendargelos/package

gha_language: JavaScript

repo_name: juliendargelos/package


text:
# ChicoACM-Competition
An all in one programming competition solution

# Website

## A user view

Should be a nice user interface where people competitng can easily create serious or throwaway accounts
Be able to view a list of problems for a given compeition
Click a specific problem and see the description, sample output and be able to subit their code for testing

BONUS: Add a real time chat system where contestant can ask judges question about problems

 ## An admin view
 Add problems to the compeititon.
 Possibly design problem statements in .yml
 Define things like time restraints in this file
 When a user submits the problem this file will travel to the backend

 BONUS: Reply to real time chat from contestants or blast global messages

 # BackendTesterGraderThingy
 A docker container running a rest server waiting for requests from the website
 This container will spawn off sibling build containers that then compile and exectue the code given to them

 Sibling containers are good https://www.develves.net/blogs/asd/2016-05-27-alternative-to-docker-in-docker/
 Reduces the docker inception going on

 Use this sweet python docker libary on the backend to create new containers and monitor their exit codes
 https://docker-py.readthedocs.io/en/stable/

# General Project Diagram
![alt text](Images/diagram.jpg)

gha_language: Python


text:
# Styling

## Font-sizes

Font sizes range from xs, s, sm. md. lg and xl and have a corresponding line-height. Use the font-size mixin to add font-sizes to styles.

i.e. `@include font-size("xs")` will add the below styles when included in a selector

`{ font-size: 0.875rem line-height: 1.5rem }`

## Margins and Paddings

To add margins and paddings to component-specific styles, use the `space(n)` function in selectors to keep spacings as multiples of 0.5rem.

Margins and Paddings can also be added to elements via utility classes i.e. `.mt-3` to add

`{ margin-top: 0.5rem * 3 }` Note that the utility classes are not responsive.

## Media queries

Media queries are created using the [include-media](https://eduardoboucas.github.io/include-media/#features) sass library. Add more breakpoints to `scss/abstracts/_breakpoints.scss partial` if needed.
To use a media query, use the `media()` mixin.
` @include media("retina2x", ">desktop") { width: 100%; }`

repository: SwipesForScience/SwipesForScience

gha_language: Vue

repo_name: SwipesForScience/SwipesForScience


text:
# Sorting Visualizer

This is a Sorting Visualizer application created using JavaScript.

Everything related to the project is located under /src/SortingVisualizer and /src/sortingAlgorithms. The SortingVisualizer component is imported and rendered in App.js.

In the project directory, you can run:

### `npm start`

Runs the app in the development mode.<br />
Open [http://localhost:3000](http://localhost:3000) to view it in the browser.

repository: MonwarAdeeb/Sorting-Vizualizer

repo_name: MonwarAdeeb/Sorting-Vizualizer


text:
# failover-vpn-firewall-set
Simple script to enable or disable iptables redirect rules for VPN through failover IP

# Usage

`wget https://raw.githubusercontent.com/UltimateByte/failover-vpn-firewall-set/master/firewall.sh`

`chmod +x firewall.sh`

`nano firewall.sh`

## Commands

`./firewall.sh enable`

`./firewall.sh disable`

## Sample output

````
root@webserver:/etc/openvpn# ./firewall.sh enable
Enable VPN rules
Allowing forwarding
Applying iptables:
 -> Redirect failover: x.x.x.x to client: <IP_ADDRESS> on network: <IP_ADDRESS>/24
[OK] Job done
root@webserver:/etc/openvpn# ./firewall.sh disable
Disable VPN rules
Disallow forwarding
Removing iptables:
 <- Redirect failover: x.x.x.x to client: <IP_ADDRESS> on network: <IP_ADDRESS>/24
[OK] Job done
````

repository: UltimateByte/failover-vpn-firewall-set

repo_name: UltimateByte/failover-vpn-firewall-set


text:
##  About
This is a personal project built in Angular. Poker Hand Comparison is a little program that will compare two hands of poker according to the rules of Texas Hold'em rules https://en.wikipedia.org/wiki/Texas_hold_%27em#Hand_values

##  Built with
- Angular 10
- Typescript
- Bootstrap

##  Functionalities
- 2 Players - User and House
- Poker hands random generation
- Poker hands comparison

##  Deployed Version
🃏 https://poker-hand-comparison.netlify.app 🃏

## Getting started
- Install all dependencies (npm install)
- Run the application (ng serve --open)
- Enter your name and play 😁

repository: sophia-ma/Poker-Hand-Comparison

repo_name: sophia-ma/Poker-Hand-Comparison


text:
---
title: Initialization
---

In many situations, we need to initialize the application (i.e perform certain actions) before listening to incoming HTTP requests. This is the case, for example, if you need to establish a connection to the database.

There are two ways to achieve this in FoalTS.

## Initializing the Application

The first approach is to add an `init` method to the root controller class which will be called before the application is fully created. This method can be synchronous or asynchronous.

*Example 1*
```typescript
import { dependency } from '@foal/core';

import { ServiceA } from '../services';

export class AppController {

  @dependency
  serviceA: ServiceA;

  async init() {
    await this.serviceA.doSomething();
  }

}
```

## Initializing a Service

The second approach is to add a `boot` method in your services. This method can be synchronous or asynchronous.

*Example*
```typescript
export class ServiceA {

  async boot() {
    await doSomething();
  }

}
```

Boot methods are executed before `AppController.init` gets called.

> If you manually inject services to your service manager and you want their `boot` methods to be called, you must specify this in the `set` method options.
>
> ```typescript
> const serviceManager = new ServiceManager();
> serviceManager.set(ServiceA, myServiceInstance, { boot: true });
> ```

## Best Practices

If your initialization consists of several asynchronous tasks, you may want to perform them in *parallel*. This will reduce the initialization time, which has an impact if you use a serverless architecture.

```typescript
export class AppController {

  async init() {
    // Don't do
    await createConnection();
    await createAnotherConnection();

    // Do
    await Promise.all([
      createConnection(),
      createAnotherConnection()
    ])
  }

}
```

repository: FoalTS/foal

gha_language: TypeScript

repo_name: FoalTS/foal


text:
# Introduction

This is a client&server for sharing clipboard between different computers which running client.

Base on `Python3` and `WebSocket`.

Support on most platform running: `Windows`, `Linux`, `Macos`

# Requirements

Run command in Python3 enviroment at source root:

```
pip3 install -r requirements.txt
```

For linux system (`client side`), install external requirements:

Ubuntu:

```
apt install xclip
```

Centos:

```
yum install xclip
```

Arch:

```
pacman -S xclip
```

# Config

Config file is saved at `data/config.json`, run command to generate it:

```
python3 config.py
```

Server and client use the same config file, Config content:

```
{
    "server_setting": {
        "host": "<IP_ADDRESS>",
        "port": 10000
    }
}
```

Server:
1. `host`: bind address of web socket server
2. `port`: bind port of web socket server

Client:
1. `host`: server address which web socket serving
2. `port`: server port which web socket serving

# Run Server

```
python3 server.py
```

# Run Client

```
python3 client.py
```

# Build Client Bin

## Prepare

We can use `pyinstaller` to build. So, install `pyinstaller` to project python env.

```
pip3 install pyinstaller
```

## Windows

Make sure `rar` command first, add path of your `winrar` bin to system `PATH`.

Save following script to `build.windows.bat` at source root:

```
@echo off

echo ========================== make dist dir
rd /s /q dist
md "dist"
md "dist\extract"

echo ========================== copy config file
md "dist\data"
copy data\config.json dist\data

echo ========================== pack python code
rem Extract Dir(for debugging): --runtime-tmpdir extract

pyinstaller ^
--runtime-tmpdir extract ^
-F client.py

rem use in cmd line: for /f %i in ('git rev-parse --short HEAD') do set git_head=%i
rem use in bat script: for /f %%i in ('git rev-parse --short HEAD') do set git_head=%%i
for /f %%i in ('git rev-parse --short HEAD') do set git_head=%%i
echo %git_head%
set year=%date:~0,4%
set month=%date:~5,2%
set day=%date:~8,2%
cd dist
rar a -k -r -s -m1 clipboard.client.windows10.x64.%year%%month%%day%.%git_head%.rar .\
cd ..

start dist
echo script finished
pause
```

Run this script in project python environment `CMD`.

## Linux

Save following script to `build.linux.sh` at source root:

```
#!/usr/bin/env bash

echo ========================== make dist dir
rm -rf dist
mkdir dist
mkdir dist/extract

echo ========================== copy logger config file
mkdir dist/data
cp data/config.json dist/data/

echo ========================== pack python code
# Extract Dir(for debugging): --runtime-tmpdir extract

pyinstaller \
--runtime-tmpdir extract \
-F client.py

chmod 755 dist/client

cd dist
git_head=$(git rev-parse --short HEAD)
build_time=$(date "+%Y%m%d")
tar -cvf clipboard.client.linux.x64.$build_time.$git_head.tar *

cd ..
nautilus dist &

```

Run this script in project python environment `bash`.

repository: wood-j/clipboard-py

repo_name: wood-j/clipboard-py


text:
---
title: Simple Octopus Tentacle Installation
categories: .Net
tags:
date: 2015-09-30 11:14:00 +10:00
---

I've been rebuilding my Octopus Deploy infrastructure to make use of the new VM, network and security support in Azure. Having to install an Octopus Tentacle on each target machine is obviously cumbersome and PowerShell is a really good answer.

The Octopus Deploy [documentation][0] already contains the bulk of the work for the script. I did find however that the netsh called failed because PowerShell didn't like it being quoted.

In order to streamline this process as much as possible, I want the script to also download the latest tentacle MSI, install it and then clean up.

<!--more-->

Drop this script into a ps1 and run it on the target server and all should be good.

```powershell
$serverThumbprint = "[YOUR-SERVER-THUMBPRINT]"
$serverUri = "[YOUR-SERVER-URI]"
$tentacleInstallApiKey = "[YOUR-TENTACLE-INSTALL-APIKEY]"
$role = "[YOUR-TENTACLE-ROLE]"
$environment = "[YOUR-TARGET-ENVIRONMENT]"

function Tentacle-Configure([string]$arguments)
{
    Write-Output "Configuring Tentacle with $arguments"

    $pinfo = New-Object System.Diagnostics.ProcessStartInfo
    $pinfo.FileName = "C:\Program Files\Octopus Deploy\Tentacle\Tentacle.exe"
    $pinfo.RedirectStandardError = $true
    $pinfo.RedirectStandardOutput = $true
    $pinfo.CreateNoWindow = $true;
    $pinfo.UseShellExecute = $false;
    $pinfo.UseShellExecute = $false
    $pinfo.Arguments = $arguments
    $p = New-Object System.Diagnostics.Process
    $p.StartInfo = $pinfo
    $p.Start() | Out-Null
    $p.WaitForExit()
    $stdout = $p.StandardOutput.ReadToEnd()
    $stderr = $p.StandardError.ReadToEnd()

    Write-Host $stdout
    Write-Host $stderr

    if ($p.ExitCode -ne 0) {
        Write-Host "Exit code: " + $p.ExitCode
        throw "Configuration failed"
    }
}

function Get-ExternalIP {
    return (Invoke-WebRequest http://myexternalip.com/raw).Content.TrimEnd()
}

Write-Output "Beginning Tentacle installation"

Write-Output "Downloading Octopus Tentacle MSI..."
$downloader = new-object System.Net.WebClient
$downloader.DownloadFile("https://octopus.com/downloads/latest/OctopusTentacle64", "Tentacle.msi")

Write-Output "Installing Tentacle"
$msiExitCode = (Start-Process -FilePath "msiexec.exe" -ArgumentList "/i Tentacle.msi /quiet" -Wait -Passthru).ExitCode
if ($msiExitCode -ne 0) {
    Write-Output "Tentacle MSI installer returned exit code $msiExitCode"
    throw "Installation aborted"
}

$ipAddress = Get-ExternalIP
Write-Output "Detected IP address as $ipAddress"

Write-Output "Configuring Tentacle"
Tentacle-Configure "create-instance --instance `"Tentacle`" --config `"C:\Octopus\Tentacle.config`" --console"
Tentacle-Configure "new-certificate --instance `"Tentacle`" --if-blank --console"
Tentacle-Configure "configure --instance `"Tentacle`" --reset-trust --console"
Tentacle-Configure "configure --instance `"Tentacle`" --home `"C:\Octopus`" --app `"C:\Octopus\Applications`" --port `"10933`" --console"
Tentacle-Configure "configure --instance `"Tentacle`" --trust `"$serverThumbprint`" --console"
netsh advfirewall firewall add rule "name=Octopus Deploy Tentacle" dir=in action=allow protocol=TCP localport=10933
Tentacle-Configure "register-with --instance `"Tentacle`" --server `"$serverUri`" --apiKey=`"$tentacleInstallApiKey`" --publicHostName `"$ipAddress`" --role `"$role`" --environment `"$environment`" --comms-style TentaclePassive --console"
Tentacle-Configure "service --instance `"Tentacle`" --install --start --console"

Write-Output "Installation Tentacle"

Remove-Item "Tentacle.msi"
Remove-Item $PSCommandPath
```

[0]: http://docs.octopusdeploy.com/display/OD/Automating+Tentacle+installation

license: MIT,Unlicense

detected_licenses: MIT Unlicense

gha_language: SCSS


text:
# Messages

Message is an [json](https://en.wikipedia.org/wiki/JSON) object that is send between all elements of this project. This project assumes that string fields in json objects can contain newline characters marked as `\n`.

> Example json objects may contain comments (text after `//`), although it is important **not** to use comments when communicating as it is not part of the standard.
## Overview of how transmitted message looks in general
```javascript
{
	// Always required:
	"type": "request or response or info",
    // Always required:
	"program": "program name",
	// Not always required (not required in info):
	"id": 234, // Can be acquired from RESTful API
	// Always required:
	"msg": { // This needs to be an object
		"Field1" : 123,
		"Field2" : "Some info"
	}
}
```
## Types of messages
There are three types of messages. The type is specified via `type` field.
1. Response - Response message to the request message that program has received.
2. Request - Request to the program from client.
3. Info - Some kind of information transmitted from program to all clients.

## Some other notes

1. Message ID when sending request from webpage to server is acquired via RESTful API.
2. Info messages don't have an ID.

repository: WojciechWnek/Toster

repo_name: WojciechWnek/Toster


text:
# sf-continent-country-type

## Introduction

This is a Symfony 3/4/5 bundle that provides a new form-type called "ContinentCountryType".  This type is like Symfony's `CountryType` but allows developers to group countries by continent.  The list of countries and continents that are displayed can be easily customised.

## Screenshots

Example of a dropdown with countries grouped by continent:
![dropdown with countries grouped by continent](Resources/doc/img/grouped.png)

Example of a simple country dropdown:
![simple country dropdown](Resources/doc/img/not-grouped.png)

*Note: the *Select2* *jQuery* plugin has been applied to the above lists.*

## Installation

* Run `composer require powderblue/sf-continent-country-type`
* Update your project `app/AppKernel.php` file and add the bundle to the `$bundles` array:
```php
$bundles = [
    // ...
    new PowderBlue\SfContinentCountryTypeBundle\PowderBlueSfContinentCountryTypeBundle(),
];
```

## How to use

In the `buildForm` method of a form-type class, specify `ContinentCountryType::class` as the type. Don't forget to include the form type class:
```php
use PowderBlue\SfContinentCountryTypeBundle\Form\Type\ContinentCountryType;
```

Here is an example:
```php
$builder
    // ...
    ->add('country', ContinentCountryType::class, [
        'label' => 'Country',
        'attr' => [
            'placeholder' => 'Country',
        ],
    ])
;
```

## Configuration

Below you can find a reference of all configuration options with their default values:
```yml
# config.yml
powder_blue_sf_continent_country_type:
    file: %bundle_root_dir%/Resources/data/continent_country.csv
    group_by_continent: true
    provider: powder_blue_sf_continent_country_type.provider.continent_country_csv_file
```

### Options

- `file` - specifies the path of the file that contains countries (and continents) that should appear in the dropdown
- `group_by_continent` - specifies whether the countries should be grouped by continent in the dropdown
- `provider` - represents the ID of the service that is used to parse the countries file; it should implement the `PowderBlue\SfContinentCountryTypeBundle\Provider\ContinentCountryProviderInterface` interface

repository: powderblue/sf-continent-country-type

gha_language: PHP

repo_name: powderblue/sf-continent-country-type


text:
# Spinach::Reporter::Console

[![Gem Version](https://fury-badge.herokuapp.com/rb/spinach-console-reporter.png)](http://badge.fury.io/rb/spinach-console-reporter)

This is a reporter that meant to use on Jenkins, combined with (https://github.com/dblock/jenkins-ansicolor-plugin) to bring the color output to Jenkins console.

See the comparison:

### Before

![before](https://raw.github.com/ywen/spinach-console-reporter/master/images/before.png "Before")

### After

![after](https://raw.github.com/ywen/spinach-console-reporter/master/images/after.png "After")

## Installation

Add this line to your application's Gemfile:

    gem 'spinach-console-reporter'

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install spinach-console-reporter

## Usage

```bash
$ bundle exec spinach -r console
```
## Contributing

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

repository: ximus/spinach-console-reporter

repo_name: ximus/spinach-console-reporter


text:
# N1.2: Submitting Norms

To submit a Norm, please use the form below.

## [Submit a Norm](https://forms.gle/Q6SMdvfYutR9DsSX6)

gha_language: HTML


text:
# social-media-app
Social Media App based on the tutorial "React / GraphQL Course - Build a social media app (MERNG Stack)"

##
Uses the following technologies: mongoose, graphql, mongodb atlas, express in the background for routing, nodemon package for auto restart when changing


text:
---
hrs_structure:
  division: '2'
  volume: '11'
  title: '26'
  chapter: 480D
  section: 480D-3
type: hrs_section
tags:
  - Business
menu:
  hrs:
    identifier: HRS_0480D-0003
    parent: HRS0480D
    name: 480D-3 Prohibited practices
weight: 19015
title: Prohibited practices
full_title: 480D-3 Prohibited practices
---
**[§480D-3] Prohibited practices.** It shall be a prohibited practice for any debt collector to engage in any of the following practices while collecting a consumer debt:

(1) To threaten the use of violence or other criminal means to cause harm to the physical person, reputation, or property of any person;

(2) To falsely accuse or threaten to falsely accuse any person of fraud or any other criminal conduct;

(3) To make false accusations or threaten to make false accusations, to another person, including any credit reporting agency, that a debt has not been paid;

(4) To threaten that nonpayment of a debt will result in the arrest of any person;

(5) To threaten to turn over the collection of the debt to a person who will engage in practices prohibited by this section;

(6) To threaten to sell or assign the debt with statements that, or implying that, the sale or assignment will cause the debtor to lose a defense or legal right as a result of the sale or assignment;

(7) To use profane or obscene language that is intended to abuse the hearer or reader;

(8) To disclose, publish, or communicate any false and material information relating to the indebtedness;

(9) To represent that an existing obligation may be increased by attorney's fees, investigation fees, service fees, and other fees or charges when in fact the fees or charges may not legally be added to the existing obligations;

(10) To seek or obtain any statement or acknowledgment that the debt was incurred for necessities of life when in fact the debt was not so incurred; or

(11) To collect or attempt to collect any interest, charge, fee, or expense incidental to the debt unless the additions are authorized by the agreement or by law. [L 1987, c 191, pt of §2]

repository: SamMade/BlueAndKrabby

repo_name: SamMade/BlueAndKrabby


text:
# dicomweb-proxy
[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fknopkem%2Fdicomweb-proxy.svg?type=shield)](https://app.fossa.io/projects/git%2Bgithub.com%2Fknopkem%2Fdicomweb-proxy?ref=badge_shield)

A proxy to translate between dicomweb and traditional dicom dimse services

## Description
* A nodejs tool to easily connect a DICOMWEB capable DICOM viewer to a legacy PACS that only knows DIMSE services. Comes with preinstalled OHIF DICOM Web Viewer.

## Prerequisite

* nodejs 12 or newer

## Setup Instructions - npm

* install in empty directory
```npm install dicomweb-proxy```

* update config file located in:
```./node_modules/dicomweb-proxy/config```

* run:
```npx dicomweb-proxy```

## Setup Instructions - source

* clone repository and install dependencies
```npm install```

* update config file located in:
```./config```

* run:
```npm start```

## What to modify
* (optional) change source port or AET

```
config.source = {
  aet: "SOURCE_AET",
  ip: "SOURCE_IP",
  port: "SOURCE_PORT"
};
```

* change target to your PACS

```
config.target = {
  aet: "TARGET_AET",
  ip: "TARGET_IP",
  port: "TARGET_PORT"
};
```

* in case your PACS does not support C-GET, switch to C-Move:
```config.useCget = false;```

* update port
```config.webserverPort = 5000;```

* open webbrowser and start viewing
e.g. ```http://localhost:5000```

## Optional: Authentication and Authorization
* you can enable keycloak authentication using the option:
```config.useKeycloakAuth```
* this requires a keycloak.json file in the root directory
* users will be redirected to keycloak server and every route is protected
* see https://codeburst.io/keycloak-and-express-7c71693d507a

## License
[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fknopkem%2Fdicomweb-proxy.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Fknopkem%2Fdicomweb-proxy?ref=badge_large)


text:
Pattern: Missing use of enqueued resource

Issue: -

## Description

Makes sure scripts and styles are enqueued and not explicitly echo'ed.

Inlining images, scripts or styles has been a common work around for performance problems related to HTTP 1.x As more and more of the web is now served via newer protocols (SPDY, HTTP 2.0) these techniques are now detrimental as they cannot be cached and require to be sent every time with the parent resource.

## Further Reading

* [VIP Go](https://vip.wordpress.com/documentation/vip-go/code-review-blockers-warnings-notices/#inline-resources)
* [WordPress.WP.EnqueuedResources](https://github.com/WordPress/WordPress-Coding-Standards/tree/develop/WordPress/Sniffs/WP/EnqueuedResourcesSniff.php)

repository: Adroiti/docs-for-code-review-tools

repo_name: Adroiti/docs-for-code-review-tools


text:
.dotfiles

My personal .dotfiles 🗃

---

## Current Machine

- Fedora + GNOME

## Uh Oh! Where is Your Old Configuration?

tl;dr

- Ubuntu, 2013 - 2017
- [Debian][debian-i3], 2017 - 2023
- [Fedora Workstation][fedora-gnome], 2023.
- [Fedora Silverblue][fedora-silverblue], 2023.
- [Debian][current-os], 2023.
- [Fedora Workstation][current-os], 2023.

-== ❧ ==-

I have been using Debian since 2017 until 2021. Throughout that time, I have been using the [i3 window manager][debian-i3], specifically from 2017 to 2019.

In 2021, I landed a job, and I have to manage both my personal laptop and office laptop. The static nature of the i3 configuration forces me to use multiple branches for my dotfiles. Hence, in 2022 I migrated to a WM that has a dynamic configuration, [bspwm][debian-bspwm].

After watching some YouTube videos that praise Fedora, I took my plunge and reinstalled both of them to [Fedora Workstation][fedora-gnome] in 2023.

Several months passed and I break it. I migrate to [Fedora Silverblue][fedora-silverblue] for obvious reasons. Turns out I can't flash my custom keyboard using a containerized environment. At the same time, my office requires me to install an app that writes to `/usr`.

Last week, RedHat goes "closed source" and Fedora attempted to have a telemetry for its user. I go back to where I am from, [Debian][debian-gnome].

Unfortunately, I haven't come across any Linux distribution that offers a desktop experience as polished as [Fedora][current-os].

[debian-i3]: https://github.com/azzamsa/dotfiles/commit/f395081a1c0372aa10737f104640da3049a5a8b2
[debian-bspwm]: https://github.com/azzamsa/dotfiles/commit/59c6e48ca7024aa810a9c892d55d4dfcb758a989
[fedora-gnome]: https://github.com/azzamsa/dotfiles/commit/6dc9d319cae13f79db0a8b1004aa87b103520415
[fedora-silverblue]: https://github.com/azzamsa/dotfiles/tree/4543ab38b5834cd1e4ba549436220c02310264dd
[debian-gnome]: https://github.com/azzamsa/dotfiles/commit/241d0c322a1511daa7253fea934c072cd05e68c5
[current-os]: https://github.com/azzamsa/dotfiles

## Usage

```bash
$ # clone the repository
$ git clone https://github.com/azzamsa/dotfiles ~/dotfiles/

$ # let GNU stow handle the symlink
$ for d in ~/dotfiles/*/ ; do
    stow --no-folding --restow "$d"
done
```

## Contribution

I won't be accepting any functionality or behavior changes. But it is OK for fixes and refinement.
I don't recommend using this repository directly. Instead, use it as a source of inspiration.

## See Also

- [azzamsa/camp.d: 🏕 I want to go camping....](https://github.com/azzamsa/camp.d)
- [azzamsa/minemacs.d: 📜 My personal MinEmacs configuration](https://github.com/azzamsa/minemacs.d)
- [azzamsa/doom.d: 📜 My personal Doom Emacs configuration](https://github.com/azzamsa/doom.d)
- [azzamsa/emacs.d: 📜 My personal Emacs configuration](https://github.com/azzamsa/emacs.d)

## Credits

- [Noto Emoji](https://github.com/googlefonts/noto-emoji) by Google

repository: azzamsa/dotfiles

repo_name: azzamsa/dotfiles


text:
# AffinityPropagation
# Language: Python
# Input: CSV (network)
# Output: CSV (clusters)
# Tested with: PluMA 1.0, Python 2.7

PluMA plugin that runs the Affinity Propagation (AP) clustering algorithm (Frey and Dueck, 2007).
AP is particularly useful when finding clusters in a signed and weighted network, and you do not
know the number of clusters in advance.  AP operates by finding exemplar nodes that represent
each cluster and uses message passing to determine these exemplars.

Expected input is a CSV file representing the network, where rows and columns both represent
nodes and entry (i, j) is the weight of the edge from node i to node j.

The output CSV file of clusters will be in the following format:

"","x"
"1","Family.Lachnospiraceae.0001"
"2","Family.Ruminococcaceae.0003"
"3","Family.Lachnospiraceae.0029"
"4","Family.Lachnospiraceae.0043"
"5","Family.Ruminococcaceae.0019"
"6","Family.Lachnospiraceae.0095"
"","x"
"1","Family.Porphyromonadaceae.0005"
"2","Family.Porphyromonadaceae.0006"
"3","Family.Lachnospiraceae.0045"
"4","Order.Clostridiales.0007"
"","x"
"1","Kingdom.Bacteria.0001"
"2","Family.Porphyromonadaceae.0013"
"3","Phylum.Firmicutes.0004"
.....

Each "","x" marks the start of a new cluster.  Note PluMA also has a ClusterCSV2NOA plugin
that can convert a file like this to a NOde Attribute (NOA) file for Cytoscape.  Nodes
can then be visualized using their cluster identifier as an attribute.

repository: unicornlll/AffinityPropagation

repo_name: unicornlll/AffinityPropagation


text:
---
title: Section links
---
Description: displays a set of links in a card layout.
## Status: Alpha
### Notes:
- The way the icons are rendered is deprecated and will need to be updated here once refactored.

### Contains:
- [@atoms/05-icons/cat-icon](?p=atoms-cat-icon)
- Either:
  - [@atoms/decorative-link](?p=atoms-decorative-link)
  - [@molecules/callout-link](?p=molecules-callout-link)

### Variations:
- [Section Links with Callout Links](?p=molecules-section-links-with-callout-links)
- [Section Links with See All](?p=molecules-section-links-with-see-all)

### Used in:
- [@organisms/by-author/sections-three-up](?p=organisms-sections-three-up)

### Variables
~~~
sectionLinks: {
  catIcon: {
    icon:
      type: string/path to icon
    small:
      type: boolean/true
  },
  title: {
    href:
      type: url/required
    text:
      type: string/required
  },
  description:
    type: string
  type:
    type: string/optional ("callout" || defaults to "decorative")
  links: [{
    href:
      type: url/required
    text:
      type: string/required
  }]
  seeAll: {
    href:
      type: url
    text:
      type: string
  } / optional
}
~~~

repository: palvick/mayflower

repo_name: palvick/mayflower


text:
---
title: One search engine for the whole internet is not a good idea anymore!
date: 2019-08-04T18:23:51.549Z
description: >-
  The overwhelming information abundance we are facing now is nothing new. It
  has started long time ago. Instead of solving this problem we decided to dance
  around it. And out came a whole new industry; SEO. Long story short, We want
  to replace Google and build one search engine for every country.

  No giggling at the back, please
image: /img/internet_map.jpg
---
> _Image copyright Wikimedia Commons_

We are living in an era where information overload is beyond comprehension. If you use one search engine for the whole internet it won’t work most of the time. Be it information, news or product, job. We want to build one search engine for every single country to overcome this ordeal.

The enormous scale of the today’s data is beyond comprehension. And it’s growing exponentially every day. And it’s getting worse everyday. Now a days every country alone generates a large volume of data everyday. The World Wide Web has passed a long journey. It’s not only about the global information we seek.  We do use it in most of modern day services.

## Search is not a Q/A

Information we seek in internet are of mainly two types:

* We know what we are looking for
* We don’t know what we are looking for

Either way traditional search engines behave to get you a list of possible items with almost no way to drill it down.

One search engine for the whole internet will make you to search multiple times to get what you want. The idea behind it is you ask a question and it will show you a possible list of items. That’s it!

There are others (amazon, linkedin, netflix) who would get you filters but those are focused on one type of information. also called vertical search engine

* Search within results
* Facet
* Tag based taxonomy
* Range queries

These features could become very handy in this case. Search is more like a journey to seek what you are looking for. It’s an experience. We believe the search engine should guide you through the journey. It might ask you questions while doing it and help you act accordingly. It should also recommend you items based on your interaction.

## Systems who restrict this information overflow are becoming popular

If we look into the recent popular systems it’s prevalent that people are tired of this information overload. That’s why systems like twitter, vine, periscope, snapchat became so popular. It’s the time to remove the clutters in search engine.

## Not everyone speaks English

If we use one search engine for the whole internet it gotta be in english. There is no doubt about that. But there are at least 500 languages in the world. and Everyone adore theirs’. There is one country who has even fought a bloody war to speak their minds in their own language. Bangladesh it is! Almost everything of black and white is in Bangla for them. We know there are others as well who does the same.

## There are new technologies which could play a vital role in Information Retrieval systems

Since we decided to come up with the idea of SEO instead of decentralising it there has been a lot of new algorithms, design patterns immersed. Big players seems not interested in those. We decided to embrace it. We integrated CLIR Cross Language Information Retrieval. It means when you search for an english word it would also get you items with it's meaning and vice versa. If you want to see it in action please visit

## One search engine can never be realtime

Every country is generating a lot of data everyday. Using one search engine could never be realtime. You will notice that the search results are horribly outdated. I won’t blame anybody. It really takes time to crawl a whole website and get back to it for a recrawl.

## Important information also served in local outlets

The world has become smaller in terms of communication. We know the important stuff around the world instantly as it happens. This made it obvious that the same information is also published in native languages. There are many people who would understand better if it were in their mother tongue.

## There was a time when Yahoo was the most important company in the internet

Sooner or later the internet will have to be decentralised. It already started happening. We started with khujun.com a vertical search engine, specifically made for Bangladesh. We crawl only a specific list of websites relevant to this country. People are loving it. We are working to release it in Saudi Arabia, Nigeria and Mexico.

## User should be in control and see everything in result

For instance the website crawl metadata and result scoring should be displayed to the user. Also we think if it has an image to represent the content it should be shown as a thumbnail. Which we do. We are also let the user sort the results based on the data.

## There are so many valid results for a query

Let’s say we are looking for the price offerings of iPhone among the local ecommerce websites. As of now we can use Google’s country specific search. and this is what I got (notice url country specific tld in screenshot):

![স্ক্রিনশট](/img/iphone.png "স্ক্রিনশট")

Every country has a mammoth collection of valid results for your query. The idea of one search engine will end up with reverse engineering the search algorithm behind it. While we could have decentralised it in the very first time. It is a bad idea to use one search engine for the whole internet.

PS: I have tremendous respect to Google for what they did and doing. Information on this post is only my opinion. No pun intended. If you have any thoughts about this post I would love to converse with you about it. You can reach me at twitter. My handle is @ferdous

repository: dynamicguy/dynamicguy

gha_language: CSS

repo_name: dynamicguy/dynamicguy


text:
A pointcloud pipeline demo.

Includes bringup scripts for a Gazebo simulation and [stereo_image_proc](https://github.com/ros-perception/image_pipeline/tree/melodic/stereo_image_proc) along with a mock image filter node that sits between images and the stereo pipeline.

## Depends

- ROS 2 (Foxy or later)

## Build

Source ROS 2 installation, for example:

        source foxy_ws/install/setup.bash

Fetch source dependencies:

        mkdir -p pc_pipe_ws/src
        cd pc_pipe_ws
        wget https://raw.githubusercontent.com/jacobperron/pc_pipe/master/pc_pipe.repos
        vcs import src < pc_pipe.repos
        rosdep install --from-paths src --ignore-src

Build:

        colcon build

## Launch simulation

Do this once per shell:

        source pc_pipe_ws/install/setup.bash

Launch the pipeline, including Gazebo simulator:

        ros2 launch pc_pipe bringup.launch.xml start_gazebo:=true viz:=true

Optional start a subscription to confirm point cloud messages are received:

        ros2 topic echo --qos-reliability reliable --no-arr /mycamera/points2

Trigger a stereo image capture:

        ros2 topic pub -1 mycamera/image_trigger std_msgs/msg/Empty

## Launch without simulation

Similar to the steps for launching the simulation, but with mock nodes for publishing images and producing a point cloud.

Do this once per shell:

        source pc_pipe_ws/install/setup.bash

Launch the pipeline:

        ros2 launch pc_pipe mock_bringup.launch.xml

Optional start a subscription to confirm point cloud messages are received:

        ros2 topic echo --qos-reliability reliable --no-arr /mycamera/points2

Trigger a stereo image capture:

        ros2 topic pub -1 mycamera/image_trigger std_msgs/msg/Empty


text:
# Blaze and Bokeh tutorial, SciPy 2015

Building Python Data Applications with Blaze and Bokeh Tutorial, SciPy 2015

# Setup

```
git clone https://github.com/chdoig/scipy2015-blaze-bokeh.git
cd scipy2015-blaze-bokeh
```

- **Option A: Anaconda**

If you don't have Anaconda installed, you can install it from [here](https://store.continuum.io/cshop/anaconda/).
After following the instructions, you should be ready to go. Check it with:

```
python check_env.py
```

If you already have Anaconda installed, make sure to update both conda and the dependencies
to the latest versions, by running:

```
conda update conda
conda install bokeh=0.9.3
conda install blaze=0.8.3
conda install ipython=3.2.3
conda install netcdf4
```

- **Option B: Miniconda or Conda Environments**

If you want one the following:

- a lightweight alternative to Anaconda, you can install Miniconda from
[here](http://conda.pydata.org/miniconda.html).

or
- isolate this scipy tutorial dependencies from your default Anaconda by using conda environments.

Follow this commands after cloning this repository:

```
cd scipy2015-blaze-bokeh
conda env create
```

If you are running Linux or OS X run:

```
source activate scipy-tutorial
```

If you are running Windows, run:

```
activate scipy-tutorial
```

# Testing

Make sure you have the right environment setup by running the following script:

```
python check_env.py
```

Also, try to run the testing notebook (0 - Test Notebook.ipynb):

```
ipython notebook
```

and run all the cells.

# Data

This tutorial will be using datasets from the following projects:

- [Berkeley Earth](http://www.berkeleyearth.org)
- [Sean Lahman Baseball](http://www.seanlahman.com/baseball-archive/statistics/)

For your convenience I have uploaded the datasets we are going to use directly to s3. Download the datasets *before* attending the tutorial from:

- https://s3.amazonaws.com/scipy-blaze-bokeh/Land_and_Ocean_LatLong1.nc ~400MB
- https://s3.amazonaws.com/scipy-blaze-bokeh/lahman2013.sqlite ~50MB

Move those datasets to the folder ``~/scipy2015-blaze-bokeh/data``

# Resources

- [Slides](http://chdoig.github.com/scipy2015-blaze-bokeh)

- Docs:

    + [Bokeh](http://bokeh.pydata.org/en/latest/)
    + [Blaze](http://blaze.pydata.org/en/latest/)
    + [Odo](http://odo.readthedocs.org/en/latest/)


text:
# Recsys Challenge 2018 - Main Track

Team: cocoplaya

Members:

 - Andres Ferraro
 - Dmitry Bogdanov
 - Jason Yoon
 - Lucas Kim

Username in recsys-challenge.spotify.com: aferraro

Instructions
-----------

In order to reproduce the recommendations submitted for the Main track of the challenge the model_main.py file must be executed.

First we train a Matrix Factorization model and then we generate the recommendations based on this model to the playlists in the challenge_set, then we combine this results with other model which computes the most probable songs based on the coocurrence in the playlists. This is all computed in the file model_main.py.

To compute the Matrix Factorization we use the library LightFM, in requirements.txt you can find all the dependencies, we use the version 3.6.4 of Python.
Inside model_main.py you can specify where the MPD dataset is located and were the challenge_set is located. Also in this file you can specify where the output CSV should be placed.

repository: andrebola/main-recsys-cocoplaya

repo_name: andrebola/main-recsys-cocoplaya


text:
# A-Team

[![Crates.io](https://img.shields.io/crates/v/ateam.svg)](https://crates.io/crates/ateam)
[![Crates.io](https://img.shields.io/crates/d/ateam.svg)](https://crates.io/crates/ateam)
[![CI](https://github.com/frisoft/ateam/workflows/CI/badge.svg)](https://github.com/frisoft/ateam/actions)
[![license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/frisoft/ateam/blob/master/LICENSE)

The tool that helps optimize the code review process.

## Install

`cargo install ateam`

Create a GitHub API token and store it in the GITHUB_API_TOKEN env variable. You can also use a .env file.

The token needs `repo` and `read:org` selected scopes.

In case your organization has enforced some sort of authorization like SAML, you need to authorize your PAT like this https://docs.github.com/en/enterprise-cloud@latest/authentication/authenticating-with-saml-single-sign-on/authorizing-a-personal-access-token-for-use-with-saml-single-sign-on

## Configuration

A-team needs to connect to GitHub's API using your GitHub API token.

You can use this [guide to create one](https://docs.github.com/en/free-pro-team@latest/github/authenticating-to-github/creating-a-personal-access-token#creating-a-token).

The token needs read access to GitHub.

You need to set the token as env variable in your shell. You can add it to your `~.bashrc`, or you can use a `.env` file in the directory you will use ateam from (or one of the parent directories):

```bash
export GITHUB_API_TOKEN=YOUR_TOKEN
```

ATeam gives you two sub-commands: `pr` and `todo`.

## ateam pr

This command helps the developers determine which pull request should be reviewed next.

To get all the pull requests of your organization (any repo), use the following command:

```bash
❯ ateam pr --org OrgName --include-mine --include-reviewed-by-me
```

The previous list also includes your pull requests and all the ones you already reviewed. You probably want to exclude them:

```
❯ ateam pr --org OrgName
```

The pull requests are in the order they are supposed to be reviewed. The first one is probably the one you should review first.

You can also search for specific pull requests. You can use the `--query` option for this. It allows you to use any condition you can use int GitHub search. The most common search is by text:

```
❯ ateam pr --org OrgName --query 'urgent'
```

Unfortunately, the `--query` option does not allow to combine texts with the OR operator.
In the case you want to search for two or more strings, you can use the `--regex` option:

```
❯ ateam pr --org OrgName --regex 'urgent|bugfix|awesome'
```

You can also filter by labels:

```
❯ ateam pr --org OrgName --label LABEL1 --label LABEL2
```

To see all the possible options, you can use `--help`:

```
❯ ateam pr --help

Usage: ateam pr [OPTIONS]

Options:
  -r, --repo <repository>
          Repositiy. Can be used multiple times to select more than one
      --org <organization>
          Selest all the repositoris of the organization
  -q, --query <QUERY>
          GitHub query. Can be used multiple times
  -n, --num <NUM>
          Number of pull requests to display
  -s, --short
          Short version. No table
      --json
          Output in JSON
      --label <LABEL>
          Filter by label. Can be used multiple times
      --exclude-label <EXCLUDE_LABEL>
          Exclude pull requests with this label. Can be used multiple times
      --regex <REGEX>
          Regexp filter on titles
      --regex-not <REGEX_NOT>
          Regexp filter on titles to exclude pull requests
      --include-reviewed-by-me
          Include pull requests I have reviewed
      --include-mine
          Include my pull requests
      --only-mine
          select only my pull requests (enables --include-reviewed-by-me automatically)
      --requested
          Select pull requests I have been requested to review, explicitly or as a code owner
      --include-drafts
          Include draft pull requests
      --include-tests-pending
          Include pull requests with pending tests
      --include-tests-failure
          Include pull requests with tests failure
      --exclude-tests-none
          Exclude pull requests without tests
      --exclude-tests-success
          Exclude pull requests with tests successful
      --tests-regex <TESTS_REGEX>
          Select tests via regexp. The others are ignored
      --required-approvals <REQUIRED_APPROVALS>
          Number of required approvals [default: 2]
      --blame
          Look if I changed the same files in the past (SLOW)
      --user <USER>
          Query for another user
      --batch-size <BATCH_SIZE>
          Mumber of pull requests requested per batch [default: 30]
  -d, --debug
          Add debug information
  -h, --help
          Print help information
```

### How does it work?

It implements a ranking system of your open pull requests.

Draft pull requests are excluded.

Pull requests with pending or failing tests are excluded as well unless you ask for them.

Pull requests you created are excluded too unless you ask for them.

Pull requests you already reviewed are excluded unless you ask for them.

Pull requests with conflicts are excluded.

It assigns a score to the pull requests. Then, it orders them by score. The highest first, the lowest last.

The ranking algorithm is based on several pieces of information:

```
 pull request score =
   last_commit_age * 2.0
   - (tests_result-1) * 2000.0
   - open_conversations * 30.0
   - (approvals - required_approvals) * 80.0
   - (reviews - required_approvals) * 50.0
   - additions * 0.5
   - deletions * 0.1
   + based_on_main_branch * 200.0
   + blame * 400.0
   + requested * 800.0
   + codeowner * 400.0
```

where

`last_commit_age` is the number of hours since the last pushed commit. So, older pull requests will appear first.

`tests_result` is 0 for successful tests, 1 for pending tests and 2 for failing tests. Note that this has only effect if
the --include-tests-failure and/or --include-tests-pending are used.

`open_conversations` is the number of conversation not resolved and not outdated.
A pull request with open conversations is already subject to reviews and discussion and, so, needs less attention.

`approvals` is the number of approvals of the pull requests, and `required_approvals` is the minimum number of approvals required (default = 2).
Approved pull requests need less attention.

`reviews` is the number of reviews the pull request received. A pull requests with many reviews needs less attention.

`additions` is the number of lines added by the pull request. Small pull requests should be reviewed first.
They might quickly unblock other pull requests. We promote small pull requests.

`deletions` is the number of lines removed by the pull request. Small pull requests should be reviewed first.
Deleted lines need to be reviewed as well, but it is usually a quicker job, so they have a lower weight in the formula.

`based_on_main_branch` is 1 if the pull request is based on the main branch. It is 0 if based on another pull request.
It is best reviewing first pull request based on the main branch.

`blame` is 1 if you changed in the past one of the first 5 files changed by the pull requiest.

`requested` is 1 if somebody requested your review explicity, not because you are a code owner.

`codeowner` is 1 if you are one of the [code owners](https://docs.github.com/en/free-pro-team@latest/github/creating-cloning-and-archiving-repositories/about-code-owners) for this pull request.

## ateam followup

This second subcommand gives you some information about the reviews you already submitted and need your attention.

The list of reviews includes:

- Dismissed reviews: A review is usually dismissed when the branch is rebased. You probably want to re-review or re-approve.
- Reviews with addressed conversations: The author replied to your questions or the conversations are outdated
  by the requested changes. The review is in this list only if all your conversations have been addressed.

## ateam todo

NOT AVAILABLE YET

Your pull requests:

- Somebody opened a conversation on your pull request. You need to reply or change the code.
- Somebody asked explicit changes to your pull request.

## Development notes

Ufficial GitHub GraphQL schema: https://docs.github.com/en/graphql/overview/public-schema

repository: frisoft/ateam

gha_language: Rust

repo_name: frisoft/ateam


text:
# Synth Playlist Wizard

Synth Playlist Wizard allows you to manage your Synth Riders playlists outside of the game.

## Disclaimer

This program is not associated with the Synth Riders development team Kluge Interactive.

## Getting Started

Grab the latest release
Execute Synth_Playlist_Wizard.exe
Enter the path to your Synth Riders directory.
Choose the preset you want to export
Hit the export button

### Prerequisites

This program has only been tested for the Steam Version of the game on Windows 10.0.18362.900.

There is currently no support for Unix and Mac systems.
Not tested for Viveport and Oculus version of the game.
Not compatible with Oculus Quest version!

## Features

* load song info from Synth Riders directory (Custom_Songs) and from synthriderz.com database
* create preset playlists (all local songs sorted by name in reversed order, bpm, duration, date, mapper and artist)

## TODO

Make a proper GUI

## License

This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details

repository: Goinn/Synth-Playlist-Wizard

repo_name: Goinn/Synth-Playlist-Wizard


text:
# Amazon Web Services [![Awesome](https://cdn.rawgit.com/sindresorhus/awesome/d7305f38d29fed78fa85652e3a63e154dd8e8829/media/badge.svg)](https://github.com/sindresorhus/awesome) ![](https://img.shields.io/badge/igorgcustodio-aws-brightgreen)

> A list of helpful articles, videos and tutorials about AWS.

*Please read the [contribution guidelines](../readme.md/#guidelines) before contributing.*

## Table of Contents

- [Cloud Front](#cloudfront)

## CloudFront

### Written

- [Host a static site using S3 and Cloud Front](
https://www.davidbaumgold.com/tutorials/host-static-site-aws-s3-cloudfront/#register-a-domain)

repository: igorgcustodio/awesome-awesome

repo_name: igorgcustodio/awesome-awesome


text:
---
layout: post
title: Why almost all forms of marketing is Scam.
---

Almost all form of marketing is ineffective.

Question is why is this so ?.

Because the questions that are being asked by almost all marketing experts are ineffective.

Why are the questions are ineffective ?.

Because they are not based upon the truth.

And if questions are not based upon The Truth, the answer one will get can not be truth.

In order to understand the truth about marketing, one must first devote himself to understanding the human nature.

Or precisely we can say, one must devote himself to understading the nature of human mind.

Have to you heard any of the marketing expert who , rather than going to school or getting a marketing degree or working at a marketing firm or something similiar, has devoted himself to learning about human mind and human nature before trying to convince a single human being on the planet to hire him?.

The truth is that human being( your costumer) do not care about what the marketing experts think.

The Truth is that human beings do not act in ways that marketers think they should act.

Most of the marketing experts are addicted to "features and benifits", this may be aurprize to many people,but "feature and benifits" are not the top of the humans's priority list.

Marketing experts are addicted to the "price", but the price matters in ways that are entirely opposite to the ways marketing experts think it matters.

Marketing experts view human being through the lens of Logic and Research.

Firstly, if human behaviour is predictable, it is on account of things that have

nothing to do with logic.

Second, almost all research is skewed and flawed. For researchers ask questions that are

1) far too narrow and self-serving, and

2) do not take into account the nuances and complexities of the human mind.

Understand this: Any business that hires a marketing firm is getting relieved of their money

for little to nothing in return.

I will conclude with a few Truths, minimally explained. For it is not about the “instruction,” but the Essence, of the message.

The one who sells the most is the one who cares not to sell it.

The one who will never starve is the one who captivates the hearts of humans.

Captivating human hearts is not a flower that can grow in the soil of “sales presentations” and “marketing strategies.”

For all sales presentations and marketing strategies are founded upon impurity and ulterior motive.

What seems to be lost on marketing an advertising agency is that the human being has an inner sense to detect what is not geniun. Thus preventing his heart from being captivated.

The company that seeks to make "extra money” is well-suited to the marketer who knows nothing about marketing.

Humans, it seems, have become conditioned to ignore their truly glorious capabilities.

The wise company will understand that it sits at the center of a flea market. If it truly seeks to do something grand, there is no “marketing agency” in existence that has sufficiently devoted its life to become worthy of their call.

If the product that a company is selling requires a “convincing” of the customer, rather than creating an instant and dramatic emotional reaction within him ( Apple  users can understand here ) , the company will struggle.

If the product that a company is selling requires a “convincing” of the customer, rather than creating an instant and dramatic emotional reaction within him, the company will struggle.

A company has found something truly magical (and easily profitable) if it creates the feeling that no price can possibly do justice to its worth.

For one may fool the mind, but he will never fool the Heart.

Jai Ho !


text:
# imgur_uploader

upload cute girl image **FROM** [Beauty board](https://www.ptt.cc/bbs/Beauty/index.html).
**TO** [imgur](https://imgur.com/a/8y0utle/).(**This is Final Result**:+1:)

## Run in local machine

#### 1. [Sign up account](https://imgur.com/)
![alt tag](https://i.imgur.com/RiqQcON.png)

#### 2. Create Album and get Album ID
![alt tag](https://i.imgur.com/DWVrkpV.png)
![alt tag](https://i.imgur.com/O15Aqpx.png)
![alt tag](https://i.imgur.com/795KxSV.png)

#### 3. [Create App](https://api.imgur.com/oauth2/addclient)
![alt tag](https://i.imgur.com/ZZyL4gh.png)

#### 4. Get app ClientID and Client_Secret
![alt tag](https://i.imgur.com/o8KD2br.png)

#### 5. Get Access token and Refresh token
- Edit auth.py
```
self.client_id = # YOUR ClientID
self.client_secret = # YOUR Client_Secret
```
- and run
```
python auth.py
```
- go to web url in terminal
![alt tag](https://i.imgur.com/ZRtnEJB.png)
- get pin code and enter pin code

#### 6.


text:
# Plays

dsa-deploy.yml

Deploys the Deep Security agent to the node1

dsa-activate.yml

Activate the Deep Security agent when it's already installed on the node

dsa-assign-policy-by-id.yml

Assign a specific policy to the Deep Security agent by the policy ID

dsa-assign-policy-by-name.yml

Assign a specific policy to the Deep Security agent by the policy name

dsa-activate.yml

Activate the Deep Security agent when it's already installed on the node

dsa-check-in-with-manager.yml

Asks the Deep Security agent to check in with the Deep Security manager (forced heartbeat

dsa-create-diagnostic-package.yml

Creates a diagnostic package for the agent and send it to the Deep Security manager

dsa-create-integrity-baseline.yml

Create a baseline for the integrity monitoring engine

dsa-reset.yml

Reset the configuration information for the Deep Security agent

dsa-recommend-security-policy.yml

Scans the node and recommends a security policy based on the current profile of the node

dsa-scan-for-integrity-changes.yml

Scans the node for changes to the filesystem and memory based on the rules running in the integrity monitoring engine

dsa-scan-for-malware.yml

Scans the node for malware

1Only the dsa-deploy.yml play requires any data to be passed through vars/. These requirements are outlined in the /README.md#vars section of the main README. All other recipes run without any additional vars.


text:
##  DataShift Spree

Import and Export Spree E-Commerce models through .xls or CSV  files, including
all associations and setting configurable defaults or over rides.

Wiki here : **https://github.com/autotelik/datashift_spree/wiki**

### Versions

This release has been tested against Spree 3.1

## Installation

Requires datashift.

Add to bundle :

    gem 'datashift'
    gem 'datashift_spree'

Most functionality provided via command line tools, so create a high level .thor file

thor will search root or lib/tasks so for example you can place it in `lib/tasks/shop.thor`

And then copy in the following

```ruby
require 'datashift'
require 'datashift_spree'

DataShift::load_commands
DataShift::SpreeEcom::load_commands
```

To check the available tasks run thor list with a search term, for example

```ruby
    bundle exec thor list datashift
    bundle exec thor list datashift_spree
```
To check latest usage information use ```thor help <command>```

for example

```ruby
    bundle exec thor help datashift_spree:load:products
```

### Usage

##### Template Generation

For loading data, probably the first thing you'll want to do is create an Excel template for the model(s) you wish to import.

This can be accomplished with the task `datashift:generate:excel`

For example to create a template for loading Spree Products, including all associations

```ruby
thor datashift:generate:excel -m Spree::Product --associations -r tmp/product_template.xls
```

##### Data Import/Export

High level thor command line tasks for import/export provided.

Specific loaders and command line tasks provided out the box for **Spree E-Commerce**,
enabling import/export of Product data including creating Variants with different
 count on hands and all associations including Properties/Taxons/OptionTypes and Images.

Loaders can be configured via YAML with over ride values, default values and mandatory column settings.

Many example Spreadsheets/CSV files in spec/fixtures, fully documented with comments for each column.

## Testing

We use RSpec, so tests located in the spec subdirectory.

To test this gem we require an actual Spree store, so when the specs are first run
a dummy Rails app is created containing a Spree store, whose version we can control in `spec/Gemfile`
so it's easy to change the Spree version and re-run the specs.

It's therefor recommended that all testing be done in spec dir itself, so first cd into spec

Edit `spec/Gemfile` and set the version of Spree you wish to test against and run bundler :

```ruby
    cd spec
    bundle install
```

When changing Spree versions, you should force a rebuild of a clean sandbox, and removing the Gemfile.lock will
resolve any funny version issues, so  run:

```ruby
    cd spec
    rm -rf dummy
    rm -rf Gemfile.lock
```

thor datashift:spree_tasks:build_sandbox

The next time you run rspec the sandbox will be regenerated using the latest versions of Rails/Spree specified in your Gemfile

```ruby
    bundle exec rspec -c .
```

## License

Copyright:: (c) Autotelik Media Ltd 2012

Author ::   Tom Statter

Date ::     Oct 2012

The MIT License

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.

extension: markdown


text:
# COVID-19 Cases Worldwide Dataset from ECDC

## What is this?

The goal of this project is to provide downloader and loader for geographic distribution of COVID-19 cases worldwide dataset from [ECDC's website](https://www.ecdc.europa.eu/en/publications-data/download-todays-data-geographic-distribution-covid-19-cases-worldwide).

*We highly recommend to use this or similar script or module instead of downloading the dataset each time from the server of ECDC to spare data usage and keep bandwidth for other researchers and developers as well.* Both solutions here checks whether today's data is downloaded yet or not and downloads only in case if it is needed.

## Parts of the project

### Python script to use as downloader or as a module

The file ` ecdcloader.py ` is a python script designed to be used as a module or as a downloader at the same time.

#### As module

Simpla paste the file ` ecdcloader.py ` into your working directory and add ` import ecdcloader ` line to your code. After importing the module, the variable ` dataset ` will contain the actual data in the form of ` pandas.DataFrame() `.

#### As script

Simply run ` ecdcloader.py ` and you'll get the newest file.

#### Fine tuning

If you want to use different settings

- ` LOAD_LASTDATA_IF_DOWNLOAD_FAILS ` Constant to specify fallback behavior. If True, tries to get data from yesterday. (Default value: *True*)
- ` TRYING_LIMIT ` Number of trying if error occurs during download. (Default value: *3*)
- ` LINK_CORE ` Root link of ECDC website's download area. (Default value: *https://www.ecdc.europa.eu/sites/default/files/documents/*)
- ` FILENAME_CORE ` Set xlsx file prefix (Default value: *COVID-19-geographic-disbtribution-worldwide-*)

### Python script and its binary to use as executable

The windows executable ` getdailyecdc.exe ` is built from ` getdailyecdc.py ` you can check it's virus-free status at [jotty's page](https://virusscan.jotti.org/en-US/filescanjob/1xzi4o68p0) or you can check the result of the query [here](https://github.com/hyperrixel/COVID19CasesWorldwideDatasetFromECDC/blob/master/virus_free_proof.jpg).

The executable accepts command-line parameters.

#### Command-line parameters

- ` -h ` ` --help ` Displays help screen.
- ` -f DAYS ` ` --fallback-days DAYS ` Sets count of fallback days. Default is ` 1 `. To pass fallback set it to ` 0 `.
- ` -p NAME ` ` --prefix NAME ` Sets xlsx file prefix. Default is "COVID-19-geographic-disbtribution-worldwide-".
- ` -r NAME ` ` --root-link NAME ` Sets download link root. Default is "https://www.ecdc.europa.eu/sites/default/files/documents/".
- ` -t TRIES ` ` --try-limit TRIES ` Sets count of download try-limits Default is ` 3 `. Use higher value in case of very bad connection circumstances.
- ` -v ` ` --version ` Shows program's version number and exits

![Screenshot - ommand line parameters in real life](ecdc-data.png)

## Future plans

Support of other filetypes: ` csv ` ` xml ` ` json `