text:
# nHentai Discord Bot (nHDBot)

nHentai Discord Bot, forked from [nana-old](https://github.com/masami45/nana-old).\
If you want to request help or new features, be sure to [join Discord Server](https://discord.gg/wm6V3cT)!

## Hosted bot
I am hosting the bot for a limited time.\
Please use [this link](https://discordapp.com/oauth2/authorize?client_id=805014850878963725&scope=bot&permissions=8) to invite the bot.

## Self Host
1. Clone this repository.
2. Rename `config.json.example` to `config.json`.
3. Modify the `config.json` file.
4. Do `npm install` or `pnpm install` or `yarn install`.
5. Do `npm start` or `pnpm start` or `yarn start`. (See Q&A below if you wish to set it up with pm2)
6. Need help? [Join Discord Server](https://discord.gg/wm6V3cT) or DM `mostidaniel!#1010`.\
If you have difficulties installing the program, please install `build-essential` and install the dependencies manually.

## Q&A
**Why can't I install this? It shows up some error.**\
Make sure that you're using Node v12.x or newer.

**How do I set it up with pm2?**\
You can use this command to start the bot using pm2: `pm2 start npm --name "app name" -- start`.\
Please view [this StackOverflow article](https://stackoverflow.com/questions/31579509/can-pm2-run-an-npm-start-script) for more information.

**How do I update this if there is a new release?**\
Just use the `git pull` command in the cloned repository directory.

**I received an error saying somewhere along the lines of `cannot find module sqlite3.node`**.\
Please uninstall sqlite from npm and reinstall it using this command: `npm install sqlite3 --build-from-source`.\
Please view [this StackOverflow article](https://stackoverflow.com/questions/20221825/node-js-says-it-cant-load-sqlite3-module-but-does-anyway) for more information.

## Differences between nHDBot and Nana ([nana-old](https://github.com/masami45/nana-old))
1. You can customize server invite link and bot name.
2. Custom prefix is reflected in all appropriate places.

## Support the original author!
Please support the original author [here](https://github.com/masami45/nana-old)!

repository: mostidaniel/nhdbot

repo_name: mostidaniel/nhdbot


text:
# NEWS

## Version 0.4.0

### Breaking

- `fieldarrays` now returns a tuple of arrays for a `StructArray{<:Tuple}`
- `push!` now only works if the `StructArray` and the element have the same propertynames
- the special constructor `StructArray(first_col => last_col)` is no longer supported

## Version 0.2.0

### Breaking

- Renamed `columns` to `fieldarrays`
- `StructArray{T}(args...)` has been deprecated in favor of `StructArray{T}(args::Tuple)`

### New features

- Added `collect_structarray` function to collect an iterable of structs into a `StructArray` without having to allocate an array of structs
- `StructArray{T}(undef, dims)` and `StructArray(v::AbstractArray)` now support an `unwrap` keyword argument to specify on which types to do recursive unnesting of array of structs to struct of arrays

license: MIT

branch_name: refs/heads/master

extension: md

gha_license_id: NOASSERTION

license_type: permissive


text:
---
author: dealingwith
date: '2005-04-30 18:55:00'
layout: post
slug: vital-interactive-media-alternate-reality
status: publish
title: Vital Interactive Media-Alternate Reality
wordpress_id: '3143'
categories:
 - nonlinear
---

[Vital Interactive Media-Alternate Reality][1]

> In addition to music and audio, VIM is also involved in the development of
dynamic media experiences known as pervasive 'alternate reality' games.

In these types of games, a dynamic online world is created, consisting of
multiple websites, interactive characters, live phone numbers, emails, phone
calls to the players, instant messages and realworld clues. It's the job of
the player to follow clues, respond to realtime challenges, and solve puzzles
to progress in the story.

This is a very new, cutting edge genre that has attracted the press as well as
earned an interested player base in the hundreds of thousands, with more
interested every day. Gaming experiences have effectively been used for
promoting games, films and television shows, as well as for corporate
teambuilding and training.

The experience can provide additional story elements, run parallel to an
existing storyline, or stand completely on its own, all the while building
momentum and gaining the attention of players in a variety of demographic
markets as well as the press.

With an effective stealth launch and no 'official' tie-in admitted to by
anyone, the mystery of what's going on adds to the fun and addiction for the
players. In addition, this air of mystery inevitably leads to media coverage,
as well.

[Here is the entry point to a recent game][2]. Start poking around and see if
you can find out how deep the rabbit hole goes! Or, if you'd like a shortcut
to more, click here.

   [1]: http://www.vpmusic.com/arg.html

   [2]: http://www.metacortechs.com/

repository: dealingwith/poole

extension: markdown

gha_language: CSS

repo_name: dealingwith/poole


text:
# Custom Order Filters

Mesh supports the creation of separate sub-networks where 0x orders that adhere to a specific schema are shared. Each sub-network is built around a custom order filter. The custom filter defines which orders are allowed to be shared within a sub-network. For example:

- All orders for a specific asset pair (e.g., WETH/DAI)
- All orders for non-fungibles (i.e., ERC721, ERC1155)
- All orders used by a specific DApp

A custom filter may be passed into Mesh as a [JSON Schema](https://json-schema.org/) via the `CUSTOM_ORDER_FILTER` environment variable. Messages that contain orders that don't match this schema will be dropped. As a limitation, filtering is only possible by looking at the static fields of an order. So for example, it is not possible to filter orders by doing an on-chain check or sending an HTTP request to a third-party API. We don't expect that this limitation is going to be a problem in practice and it comes with the huge benefit of enabling cross-topic forwarding in the future (more on that later).

## New order and message schemas.

All orders must match the following JSON Schema:

```json
{
	"id": "/rootOrder",
	"allOf": [{
		"$ref": "/customOrder"
	}, {
		"$ref": "/signedOrder"
	}]
}
```

- `/signedOrder` is the JSON Schema that will match any valid 0x orders.
- `/customOrder` is the custom schema passed in through the `CUSTOM_ORDER_FILTER` environment variable.

Organizing the JSON Schema for orders like this means that `CUSTOM_ORDER_FILTER` can be relatively small. It doesn't need to contain all the required fields for a signed 0x order. It just needs to contain any _additional_ requirements on top of the default ones.

### Example custom order schemas

#### All orders:

The following `CUSTOM_ORDER_FILTER` doesn't add any additional requirements. All valid signed 0x orders will be accepted. This is the default value if no custom filter is passed in.

```json
{}
```

#### Orders with a specific sender address:

```json
{
	"properties": {
		"senderAddress": {
			"pattern": "0x00000000000000000000000000000000ba5eba11",
			"type": "string"
		}
	}
}
```

#### Mainnet WETH <-> DAI orders:
```json
{
    "oneOf": [
        {
            "properties": {
                "makerAssetData": {
                    "pattern": "0xf47261b00000000000000000000000006b175474e89094c44da98b954eedeac495271d0f",
                    "type": "string"
                },
                "takerAssetData": {
                    "pattern": "0xf47261b0000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
                    "type": "string"
                }
            }
        },
        {
            "properties": {
                "makerAssetData": {
                    "pattern": "0xf47261b0000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
                    "type": "string"
                },
                "takerAssetData": {
                    "pattern": "0xf47261b00000000000000000000000006b175474e89094c44da98b954eedeac495271d0f",
                    "type": "string"
                }
            }
        }
    ]
}
```

#### Any ERC721 order:

```json
{
    "oneOf": [
        {
            "properties": {
                "makerAssetData": {
                    "pattern": "0x02571792.*",
                    "type": "string"
                }
            }
        },
        {
            "properties": {
                "takerAssetData": {
                    "pattern": "0x02571792.*",
                    "type": "string"
                }
            }
        }
    ]
}
```

#### Augur V2 orders:

```json
{
    "properties": {
        "makerAssetData": {
            "pattern": ".*${AUGUR_ERC1155_CONTRACT_ADDRESS}.*"
        }
    }
}
```

Where `${AUGUR_ERC1155_CONTRACT_ADDRESS}` needs to be replaced with the Augur ERC1155 token used to represent the outcomes of their various prediction markets.

As you can see by the above examples, JSON-Schema has support for [regular expressions](https://json-schema.org/understanding-json-schema/reference/regular_expressions.html) allowing for partial matching of any 0x order field.

## Limitations

Nodes that are spun up with a custom filter will share all their orders with nodes that are either using the exact same filter or the default "all" filter (i.e., "{}"). They will _not_ share orders with nodes using different custom filters (even if a given order matches both filters) because each filter results in a separate sub-network. Therefore, custom filters are most useful for applications where users care about a distinct subset of 0x orders.

If you wanted to connect two sub-networks with overlapping valid orders, you could spin up a Mesh node for each sub-network and additionally run a [bridge script](https://github.com/0xProject/0x-mesh/blob/master/cmd/mesh-bridge/main.go) to send orders from one sub-network to the other. Longer term, we hope to add support for cross-topic forwarding, which will allow Mesh nodes to do this under-the-hood.

gha_language: Go


text:
# Artificial Intelligence in Java-Game Strategy
### This project is trying to develop an AI for 3 games

### 1. Four-in-a-line [(Code)](https://github.com/Hank-Tsou/Artificial-Intelligence-four-in-a-line)
```
Algorithm: Minimax algorithm with alpha-beta pruning
```

![](four_in_a_line.jpg)

### 2. N-queen [(Code)](https://github.com/Hank-Tsou/Artificial-Intelligence-N-queen)
```
Algorithm: (1) Genetic Algorithm (2) Simulate Annealing Algorithm
```

![](N_queen.jpg)

### 3. 8-puzzle [(Code)](https://github.com/Hank-Tsou/Artificial-Intelligence-8-puzzle)
```
Algorithm: 'A' star Algorithm with 2 different heuristic function
  * h1: (the number of misplace tiles)
  * h2: (Manhattan Distance)
```

![](8_puzzle.jpg)

## Code
* [Four-in-a-line](https://github.com/Hank-Tsou/Artificial-Intelligence-four-in-a-line)
* [N-queen](https://github.com/Hank-Tsou/Artificial-Intelligence-N-queen)
* [8-puzzle](https://github.com/Hank-Tsou/Artificial-Intelligence-8-puzzle)

## License

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

## Reference

* Author: Hank Tsou
* Contact<EMAIL_ADDRESS>


text:
Previous |
Index |
Next

# Finite State Machines

### FSMs as fundamental building blocks

Finite State Machines are the fundamental abstraction Alogic uses to describe
the sequential behaviour of digital logic. Every Alogic entity describing
sequential logic is eventually emitted as some Verilog modules implementing
FSMs.

### FSM syntax

FSMs are introduced with the `fsm` keyword, followed by the name of the FSM,
followed by the description of the FSM in curly brackets. The behaviour of an
FSM is described using code with sequential semantics, portions of which execute
on every clock cycle.

This FSM reads a byte from an input port on every clock cycle, increments its
value by 2 and writes the result to an output port:

```
fsm add2 {

  // port declarations:
  in sync u8 p_in;
  out sync u8 p_out;

  // optional entity variables
  u10 a;
  u3 b = 3'd6; // after reset, b will be initialised to 6

  // all FSMs must contain a main function:
  void main() {
    u8 x = p_in.read();
    p_out.write(x + a[7:0] + 'b);
    fence; // All functions must end with a control statement
  }
}
```

Note that variables declared in the FSM entity and variables declared
in `void main()` are all static variables. Within `void main()` there would be
no difference between using `a` and `b`, and using `x`. However, `x` is only
available inside `void main()` and would not be accessible by another function.

### Using functions for encapsulation

All FSMs must contain a `main` function. Execution starts at the beginning of
`main` after reset. FSM code can also be partitioned into multiple control
functions. If the execution reaches the end of the body of a control function,
the function returns (control is transferred to the call site). When the `main`
function returns, control is transferred to the beginning of `main` again, with
the execution thus proceeding in an infinite loop. The body of the example FSM
above takes 1 cycle to execute, then it reaches the end of `main`, and hence the
body is effectively executed on every clock cycle.

An FSM that, depending on the state of an input port, would apply one of 2
different kinds of processing could be defined using the following pattern:

```
fsm one_or_the_other {
  in bool p_which;
  ...

  void main() {
    if (p_which) {
      do_true();
    } else {
      do_false();
    }
  }

  void do_true() {
    // Do something
    ...
    return;
  }

  void do_false() {
    // Do something else
    ...
    return;
  }
}
```

### Control Units

An FSM is partitioned into one or more control units. Each control unit
corresponds to an FSM state. On every clock cycle, the FSM executes the control
unit corresponding to the current state, and moves on to a new state, which may
be the same as the current state. The control unit will consist of a list of
imperative-style statements. Statements execute sequentially, according to their
execution semantics, which are analogous to similar statements in common
imperative programming languages. Statements can be classed either as
combinational statements, or control statements. In a single control unit, there
will be a series of combinational statements (such as `a += 3'b1;`) followed by
a single control statement (such as `fence`). For a comprehensive list of
statements, see the [statements](statements.md) section of the documentation.

### Execution model

In this section, we will not go into the details of where the precise control
unit boundaries are, but we will mention the `fence` statement to aid with the
examples. For now, let it suffice to say that the `fence` statement is used to
delimit control unit boundaries in straight line code, so any combinational
statement between two `fence` statements executes in one clock cycle. For the
details of where control unit boundaries are, see the section
on [control flow conversion](control.md).

Under various circumstances, the FSM can stall. When a stall occurs, no internal
state of the FSM is updated.

### Function call model

Function calls within the FSM are tracked using a small hardware return stack.
This ensures that any function can be called from an arbitrary number of call
sites, and the compiler will take care of resuming execution of the correct code
when a function returns. The required size of the return stack is determined
automatically by the compiler, unless the FSM is recursive, as described below.
The theoretically-minded reader will note that this function call model means
that Alogic FSMs actually are more akin to pushdown automata in their
capabilities than traditional finite state machines.

### Recursive FSMs and variable allocations

Recursive functions in FSMs are permitted. Describing a directly or indirectly
recursive FSM requires that the user attaches a `reclimit` annotation to the
definition of each recursive function. The value of the `reclimit` attribute
defines how many times that function can be entered on the worst case execution
path, and must be provided by the user. The compiler will use this limit to
compute the minimum size of the return stack:

```
fsm rec {
  u8 i;

  void main() {
    i = 8'd0;
    foo();
  }

  (* reclimit = 4 *)
  void foo() {
    ...
    if (i < 8'd3) {
      i++;
      foo();
    }
    ...
    return;
  }
}
```

It is the responsibility of the designer to ensure that the actual program logic
of the FSM does not violate the specified recursion limit.

The size of the return stack can be specified explicitly using the `stacklimit`
annotation attached to the FSM itself. This can be used when the worst case
execution path contains a call stack that is smaller than the statically
computed stack size given only the `reclimit` attributes. The value of the
`stacklimit` variable should be set to the worst case number of active function
calls.

```
(* stacklimit = 5 *)
fsm rec {
  ...
}
```

Local variables of recursive functions are implemented using a hardware stack
structure. This means that each invocation of a recursive function has it's own
copy of local variables.

### The `fence` block

FSMs definitions can contain a single `fence` block. The `fence` block may only
contain combinational statements, and is executed at the beginning of every
cycle, before any of the statements of the control unit corresponding to the
current state are considered. For example:

```
fsm fenceblock {
  in u3 s_l2;
  out u8 o;
  u8 s;

  fence {
    // this line will be inserted at the start of every state case
    s = 8'd1 << s_l2;
  }

  void main () {
    // ...
    o = s;
    fence;

    // ...
    o = s + 1;
    fence;

    // ...
    o = s + 2;
    fence;
  }
}
```

Is equivalent to:

```
fsm nofencefunc {
  in u3 s_l2;
  out u8 o;
  u8 s;

  void main () {
    s = 8'd1 << s_l2;
    // ...
    o = s;
    fence;

    s = 8'd1 << s_l2;
    // ...
    o = s + 1;
    fence;

    s = 8'd1 << s_l2;
    // ...
    o = s + 2;
    fence;
  }
}

```

The `fence` block is particularly useful for computing combinational signals
dependent on local state. In the above example, as variable `s` is always
assigned at the beginning of every cycle (it is assigned in the `fence` block
and is not under a conditional), it can be implemented as a combinational
signal, with no flip-flop allocated for storing it's value.

Previous |
Index |
Next

repository: ArgonDesign/alogic

gha_language: Scala

repo_name: ArgonDesign/alogic


text:
# Change Log

## Release 1.0.3 (2021-08-20)

- Update README.MD with a known possible issue and how to fix it

## Release 1.0.2 (2021-08-20)

- Fix a bug causing the plugin to set prefix too many places due to nesting in SASS

## Release 1.0.1 (2021-08-20)

- Update README.MD with a list of options
- Add "publish" script to package.json
- Update "repository" in package.json

## Release 1.0.0 (2021-08-20)

- Initial release

repository: larsmunkholm/postcss-prefix-hover

branch_name: refs/heads/main

repo_name: larsmunkholm/postcss-prefix-hover


text:
# ckeditor5-build-laravel-image

[![npm version](https://badge.fury.io/js/ckeditor5-build-laravel-image.svg)](https://badge.fury.io/js/ckeditor5-build-laravel-image)

Custom CKEditor 5 Classic build with support for uploading images to a Laravel endpoint. It provides
the configurations needed by Laravel for CSRF protection.

This build is based on [ckeditor5-build-classic](https://github.com/ckeditor/ckeditor5-build-classic)
and uses the [ckeditor5-simple-upload](https://github.com/pourquoi/ckeditor5-simple-upload) plugin
to upload the images to the Laravel application.

Laravel has a [CSRF protection](https://laravel.com/docs/master/csrf), so you have to send a CSRF
token or add an exception to the `VerifyCsrfToken` middleware (not recommended).

## Installation

```shell
npm i ckeditor5-build-laravel-image
```

## Usage

First, you have to set your token in a meta tag:

```html
<meta name="csrf-token" content="{{ csrf_token() }}">
```

Then, you can create an instance of the editor:

```javascript
ClassicEditor.create(document.querySelector('#editor'), {
  simpleUpload: {
    uploadUrl: {
      url: 'http://localhost:9000/my-laravel-endpoint'
    }
  }
}).then(editor => {
  console.log('Editor created successfully!');
}).catch(err => {
  console.error(err.stack);
});
```

Where `simpleUpload.uploadUrl.url` is the URL of your Laravel endpoint that manages the image
upload.

### Laravel endpoint

The endpoint requirements are the same as the
[ckeditor5-simple-upload](https://github.com/pourquoi/ckeditor5-simple-upload) plugin.

The endpoint will expect a file called `upload` and should return a response depending of the
status.

#### Success response

```json
{
  "uploaded": true,
  "url": "http://<IP_ADDRESS>/uploaded-image.jpeg"
}
```

#### Failure response

```json
{
  "uploaded": false,
  "error": {
      "message": "could not upload this image"
  }
}
```

## Features

This build includes almost the same as
[ckeditor5-build-classic](https://github.com/ckeditor/ckeditor5-build-classic), but with the
following differences.

Removed:
- [UploadAdapter](https://github.com/ckeditor/ckeditor5-adapter-ckfinder)
- [CKFinder](https://github.com/ckeditor/ckeditor5-ckfinder)
- [EasyImage](https://github.com/ckeditor/ckeditor5-easy-image)

Added the following features:
- [Block indentation](https://ckeditor.com/docs/ckeditor5/latest/features/indent.html)
- [Text alignment](https://ckeditor.com/docs/ckeditor5/latest/features/text-alignment.html)

Added from the
[Basic text styles](https://ckeditor.com/docs/ckeditor5/latest/features/basic-styles.html) feature:
- Underline
- Strikethrough
- Subscript
- Superscript
- Code


text:
# Cryptocurrency Visualization

App to visualize the price from coinmarketcap.com and other custom statistics of a specify cryptocurrency portfolio.

- [Here the app live](https://carlescg.shinyapps.io/crypto/)

![](https://github.com/CarlesCG/Crypto_Portfolio_App/raw/master/www/cover_black.png)

## Features
- Query the information on the fly
- Top 300 cryptocurrencies from coinmarketcap.com
- Bookmark your portfolio & save the link. No need to select it again.
- Custom time period

## To do:
**Heavily Work in progress!!**

- Bookmarking state not working... Fix it
- Add a progress bar with regards the querying
- Check the multicore of shinyapps.io (detecCore back to code?)
- Add table with raw data
- Add download data button
- Refer original downloading code to author


text:
---
layout: post
title: Elixir on Phoenix - OS X Quick Install
---

Here are quick installation instructions to install Elixir and the Phoenix
Framework on OS X. (For the latest, comprehensive installation instructions,
check out the [Phoenix Framework Installation
Docs](http://www.phoenixframework.org/docs/installation).)

### 1. Install Elixir (and Erlang)
Use [Homebrew](http://brew.sh/) to install Elixir.

`brew update`

`brew install elixir`

You may also need to do a `brew link erlang` or a `brew reinstall erlang`.

Elixir compiles down into Erlang for implementation with the Erlang Virtual
Machine.

### 2. Install Hex
Hex is a package manager. You will install Hex with the Mix build tool that
comes with Elixir by running `mix local.hex` on the command line.

### 3. Install Phoenix
Use Mix to install the Phoenix mix archive. The command will look something like
`mix archive.install <path_to_phoenix_mix_archive>`. The [Phoenix installation
docs](http://www.phoenixframework.org/docs/installation#section-phoenix) include
an installation command pointing to the latest stable build.

### 4. Install Node.js
Phoenix uses the npm package ecosystem that comes bundled with
[Node.js](https://nodejs.org/). If you don't already have Node.js installed, I
recommend installing it with [Node Version
Manager](https://github.com/creationix/nvm).

With npm installed, Phoenix will be able to compile static assets using
[brunch.io](http://brunch.io/).

### 5. Install Postgres
The easiest way to get PostgreSQL set up on OS X is with
[Postgres.app](http://postgresapp.com/).

Phoenix looks for a "postgres" user in the database. After installing Postgres,
you can run `psql` from the command line. Then, you will create a new user/role
with login and create permissions by entering `CREATE ROLE postgres LOGIN
CREATEDB;`. (Don't forget the semicolon!) Exit the psql interactive terminal
with Ctrl-D.

### 6. Install Phoenix
(Refer to the [Phoenix Framework Up And Running
Docs](http://www.phoenixframework.org/docs/up-and-running) for the latest,
comprehensive installation instructions.)

Finally, we have all the dependencies we need to install and run Phoenix.
Navigate to the directory where you want to create your Phoenix project
directory then run `mix phoenix.new <application_name>`. e.g. `mix phoenix.new
hello_phoenix`

If prompted, go ahead and fetch and install any dependencies in addition to the Rebar Erlang
build tool. You may need to manually run `mix deps.get` to install
dependencies as well.

After Phoenix successfully installs, navigate to the newly created directory and
run `mix ecto.create`. This will create your Postgres database.

Now, run your application with `mix phoenix.server`. You should then be able to
pull up [http://localhost:4000](http://localhost:4000) in your web browser and
see the Phoenix Framework welcome page.


text:
# What is it?
devfest-pwa-one is the most basic form of installable Progressive Web App, I implemented this as part of PWA workshop for Google Developer Group DevFest Muscat 2017

# Live Demo
Visit  https://irkan-hadi.github.io/devfest-pwa-one/ using your mobile device or desktop

# Features
- "Add to Homescreen" feature
- Offline Support

# What is used
HTML5 and Javascript

repository: irkan-hadi/devfest-pwa-one

repo_name: irkan-hadi/devfest-pwa-one


text:
## New leaderboard in-game!
This leaderboard has many features, including some mobile support! There are some terms you should know, which will now be listed.

`Sidebar` = The player leaderboard near the top right of the screen.

`Sidebar Name` = The text displayed as the username for a player on the `Sidebar`.

`Player GUI` = A GUI popup that appears when a `Sidebar Name` is clicked on, it displays the users `Display Name`, `User Tag`, `Avatar & Avatar Search`,and `User ID / Account Age`.

`Avatar & Avatar Search` = A small icon of the users avatar, and a search icon that allows you to see what they are wearing currently.

`Display Name` = The text above the `User Tag`, which is what you should call said user by.

`User Tag` = The text below the `Display Name`, in case you want to know what a players username is, but it is hidden by their `Display Name`, the `User Tag` will show you their username. Usually it appears as `@(username)`.

Mobile players are not able to hide the `Sidebar`, however the `Player GUI` is supported on mobile.

### What if a players name shows up as [REDACTED]?
 `Sidebar Name`s that appear as [REDACTED] are only given to [REDACTED] Faculty, or HRs. Their `Display Name`, `User Tag`, and `User ID`, will all be hidden to prevent username leaking, as well as their `Avatar` image, `Search Button`, Add Friend, and Block features will be disabled.

### Can I have a custom Display Name / Sidebar Name?
Yes, but those are restricted strictly to [Sponsors](https://www.campsunnydaysrblx.com/sponsor) & Discord Server Boosters. However, certain staff members may get these for free as apart of their job like [REDACTED], Researchers, HRs, and Combatives.

### Why can't I see the avatar, avatar search, add friend, or block button on some peoples player GUIs?
HRs add friend features are automatically disabled to prevent spam friend requests, and certain features like blocking players, and the avatar search button may be turned on/off by their request.

repository: NosadfacesRBLX/csdrblx

path: /In-Game Leaderboard.md

filename: In-Game Leaderboard.md

repo_name: NosadfacesRBLX/csdrblx


text:
## Probot app to sync labels outward from a given repostiory
=======

*This is not intended for external use as is, it was explicitly
implemented in an abbreviated fashion to function accordingly to
the internal uses of Containership. It is a decent
starting point if you want to fork it and make a more
generic outward label syncing solution.*

## Usage

Probot application that outwardly syncs label groups from `labels/*.yaml` to repositories configurations defined in `repositories/${owner}/${repo}.yaml` format.

`labels/{type}.yaml` - YAML file containing single key `labels` that is an array of labels of the following format:

```
labels:
  - name: ...,
    description: ...,
    color: ...
```

`repositories/{owner}/{repo}` - YAML file containing single key `labelGroups` that is an array of any named label `type` file in the `/labels` directory. The names *should include* the file extension

```
labelGroups:
  - 'base.yaml'
```

Any modifications to this repo to the `/labels` or `/repositories` directories will trigger a sync of *all labels to all repos* that are defined

> A GitHub App built with [Probot](https://github.com/probot/probot) that A probot app to outwardly sync labels

## Local Setup

```sh
# Install dependencies
npm install

# Run the bot
npm start
```

## Contributing

If you have suggestions for how probot-label-sync could be improved, or want to report a bug, open an issue! We'd love all and any contributions.

For more, check out the [Contributing Guide](CONTRIBUTING.md).

## Additional Considerations

It's not amazingly elegant but it gets the job done. Didn't want to spend too much time implementing a solution.

repository: nicktate/probot-label-sync

repo_name: nicktate/probot-label-sync


text:
# KMeans_clustering

This dataset contains data on 5000 customers. The data include customer demographic information (age, income, etc.), the customer's relationship with the bank (mortgage, securities account, etc.), and the customer response to the last personal loan campaign (Personal Loan). Among these 5000 customers, only 480 (= 9.6%) accepted the personal loan that was offered to them in the earlier campaign.

## Project structure:
1. pandas - exploring dataset,cleaning,removing outliers
2. matplotlib - data visualization
3. seaborn - data visualization
4. KMeans - clustering


text:
# Make phone calls with Python and the Bottle web framework
This code goes along with the blog post on
[Dialing Outbound Phone Calls with a Bottle Web App](https://www.fullstackpython.com/blog/dial-outbound-phone-calls-python-bottle.html)
found on the
[Full Stack Python blog](https://www.fullstackpython.com/blog.html).


text:
## Golden Sprial in TeX

This code typesets the digits of the golden ratio along the classic spiral
associated to that ratio.
The list of digits was obtained from [the Mathematics department at
Surrey](http://www.maths.surrey.ac.uk/hosted-sites/R.Knott/Fibonacci/phi10000dps.txt).

The number of digits stored is 10,001 (including the decimal point),
but for some unknown reason TeX can only do up to 9,999.  It claims to
run out of memory at that point.

(Note that the parameter includes the initial `1.` so actually typesets `N -
2` decimal places.)

In addition, for a different size diagram change the way that `\l__radius_fp`
is defined.  Currently, it produces a large diagram that almost fills the
page.

repository: loopspace/golden

repo_name: loopspace/golden


text:
# Action Add Labels

[![actions-workflow-test][actions-workflow-test-badge]][actions-workflow-test]
[![release][release-badge]][release]
[![license][license-badge]][license]

![screenshot](./docs/assets/screenshot.png)

This is a GitHub Action to add GitHub labels to an issue or a pull request.

This action extract the number from an issue or a pull request which has triggered this by default.

It would be more useful to use this with other GitHub Actions' outputs.

## Inputs

|      NAME      |                                           DESCRIPTION                                           |   TYPE   | REQUIRED |                                     DEFAULT                                     |
| -------------- | ----------------------------------------------------------------------------------------------- | -------- | -------- | ------------------------------------------------------------------------------- |
| `github_token` | A GitHub token.                                                                                | `string` | `false`   | `${{ github.token }}`                                                                           |
| `labels`       | The labels' name to be added. Must be separated with line breaks if there're multiple labels. | `string` | `true`   | `N/A`                                                                           |
| `number`       | The number of the issue or pull request.                                                        | `number` | `false`  | `N/A`                                                                           |
| `repo`         | The owner and repository name. e.g.) `Codertocat/Hello-World`                                   | `string` | `false`  | `${{ github.event.issue.number }}` or `${{ github.event.pull_request.number }}` |

## Example

### Add a single label with a comment

```yaml
name: Add Label

on:
  issues:
    types: opened

jobs:
  add_label:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - uses: actions-ecosystem/action-add-labels@v1
        if: ${{ startsWith(github.event.comment.body, '/add-labels') }}
        with:
          labels: bug
```

### Add multiple labels with a comment

```yaml
name: Add Labels

on:
  pull_request:
    types: opened

jobs:
  add_labels:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - uses: actions-ecosystem/action-add-labels@v1
        if: ${{ startsWith(github.event.comment.body, '/add-labels') }}
        with:
          labels: |
            documentation
            changelog
```

## License

Copyright 2020 The Actions Ecosystem Authors.

Action Add Labels is released under the [Apache License 2.0](./LICENSE).

<!-- badge links -->

[actions-workflow-test]: https://github.com/actions-ecosystem/action-add-labels/actions?query=workflow%3ATest
[actions-workflow-test-badge]: https://img.shields.io/github/workflow/status/actions-ecosystem/action-add-labels/Test?label=Test&style=for-the-badge&logo=github

[release]: https://github.com/actions-ecosystem/action-add-labels/releases
[release-badge]: https://img.shields.io/github/v/release/actions-ecosystem/action-add-labels?style=for-the-badge&logo=github

[license]: LICENSE
[license-badge]: https://img.shields.io/github/license/actions-ecosystem/action-add-labels?style=for-the-badge


text:
# Expression Sequencer

## TODO

### Authoring

* There is a concept of the current envelope number
* Pressing the add segment button creates a new envelope after the current one
* Pressing the forward and back buttons changes which envelope is displayed
* Pressing the rewind button jumps to the first envelope in the sequence
* There is a way to author all of the sequences

### Playback

* Pressing play runs through all envelopes
* There is a playhead displayed on the screen tracking the playing sequence
* There is an option to set the sequence to loop (another UI button -- near the shuttle controls?)

### Quantization

* Add toggle button for Y quantize
* Label notes on Y-axis for quantize display
* Fix quantize wrap-around bug
* Draw x-quantize grid
* Enforce x quantize
* Enforce quantize on output variables

### UI

* Need a button to toggle y-axis quantization
* Need a knob to control x-axis quantization
* Need a toggle to control looping
* Need controls to switch between sequences
* Need on-screen feedback about:
* * Current sequence num
* * Current location within the sequence

### Outputs

* Do we want an end-of-sequence trigger? (we could do looping through patching that to the reset input)

## To build

```
RACK_DIR=~/Documents/code/Rack make dist; cd ~/Documents/code/Rack; make run; cd plugins/ExpressionSequencer
```

(from the plugin directory (symlinked inside Rack's plugin dir))

repository: atduskgreg/ExpressionSequencer

repo_name: atduskgreg/ExpressionSequencer


text:
# HTML Beautifier

A normaliser/beautifier for HTML that also understands embedded Ruby.
Ideal for tidying up Rails templates.

## What it does

* Normalises hard tabs to spaces (or vice versa)
* Removes trailing spaces
* Indents after opening HTML elements
* Outdents before closing elements
* Collapses multiple whitespace
* Indents after block-opening embedded Ruby (if, do etc.)
* Outdents before closing Ruby blocks
* Outdents elsif and then indents again
* Indents the left-hand margin of JavaScript and CSS blocks to match the
  indentation level of the code

## Usage

### From the command line

To update files in-place:

``` sh
$ htmlbeautifier file1 [file2 ...]
```

or to operate on standard input and output:

``` sh
$ htmlbeautifier < input > output
```

### In your code

```ruby
require 'htmlbeautifier'

beautiful = HtmlBeautifier.beautify(messy)
```

You can also specify how to indent (the default is two spaces):

```ruby
beautiful = HtmlBeautifier.beautify(messy, indent: "\t")
```

## Installation

This is a Ruby gem.
To install the command-line tool (you may need `sudo`):

```sh
$ gem install htmlbeautifier
```

To use the gem with Bundler, add to your `Gemfile`:

```ruby
gem 'htmlbeautifier'
```

## Contributing

1. Follow [these guidelines][git-commit] when writing commit messages (briefly,
   the first line should begin with a capital letter, use the imperative mood,
   be no more than 50 characters, and not end with a period).
2. Include tests.

[git-commit]:http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html

repository: threedaymonk/htmlbeautifier

gha_language: Ruby

gha_license_id: MIT

repo_name: threedaymonk/htmlbeautifier


text:
---
layout: single
title: Paper cut furniture using SketchChair
date: 2014-08-04 00:34
categories: LaserCutter
tags: chair CNC furniture LaserCutter paper
---
I found SketchChair while looking for CNC related projects on Kickstarter. It is an open source application that you can use to draw chairs and output the design files for cutting on a CNC or laser cutter.

They have an design library of chairs that other people have made using the application. I downloaded a few of them, resized the chairs to work with paper as a test. The modified design files can be found in laser-furniture repo on my github account.

gha_language: SCSS


text:
---
title: Getting Started
page_title: Getting Started with Xamarin.Forms Rating Control
description: Check our "Getting Started" documentation article for Telerik Rating for Xamarin control.
position: 1
slug: rating-getting-started
---

# Getting Started

This example will guide you through the steps needed to add a basic **RadRating** control in your application.

* [Setting up the app](#1-setting-up-the-app)
* [Adding the required Telerik references](#2-adding-the-required-telerik-references)
* [Adding RadRating control](#3-adding-radrating-control)

## 1. Setting up the app

Take a look at these articles and follow the instructions to setup your app:

- [Setup app with Telerik UI for Xamarin on Windows]({%slug getting-started-windows%})
- [Setup app with Telerik UI for Xamarin on Mac]({%slug getting-started-mac%})

## 2. Adding the required Telerik references

You have two options:

* Add the Telerik UI for Xamarin Nuget package following the instructions in [Telerik NuGet package server]({%slug telerik-nuget-server%}) topic.

If you don't want to add the all Telerik.UI.for.Xamarin nuget package, you have the option to add a separate nuget package. For RadShapeRating control you have to install the **Telerik.UI.for.Xamarin.Input** nuget package. This nuget will automatically refer the Telerik.UI.for.Xamarin.Primitives, Telerik.UI.for.Xamarin.Common, and Telerik.UI.for.Xamarin.DataControls nuget packages.

* Add the references to Telerik assemblies manually, check the list below with the required assemblies for **RadRating** component:

| Platform | Assemblies |
| -------- | ---------- |
| Portable | Telerik.XamarinForms.Common.dll
 Telerik.XamarinForms.Input.dll
 Telerik.XamarinForms.SkiaSharp.dll |
| Android  | Telerik.Xamarin.Android.Common.dll
 Telerik.Xamarin.Android.Data.dll
 Telerik.Xamarin.Android.Input.dll
 Telerik.Xamarin.Android.List.dll
 Telerik.Xamarin.Android.Primitives.dll
 Telerik.XamarinForms.Common.dll
 Telerik.XamarinForms.Input.dll
 Telerik.XamarinForms.SkiaSharp.dll |
| iOS      | Telerik.XamarinForms.Common.dll
 Telerik.XamarinForms.Input.dll
 Telerik.XamarinForms.SkiaSharp.dll |
| UWP      | Telerik.XamarinForms.Common.dll
 Telerik.XamarinForms.Input.dll
 Telerik.XamarinForms.SkiaSharp.dll |

>important RadRating is rendered via the **SkiaSharp** graphics library so you need to install also [SkiaSharp.Views.Forms](https://www.nuget.org/packages/SkiaSharp.Views.Forms) in all projects of the Xamarin solution (.Net Standard/Shared, Android, iOS, etc).

## 3. Adding RadRating control

If your app is correctly set, you are ready to add a **RadRating** control within your page.

The simplest and fastest way to include the control is by simply defining it like this in XAML / code-behind:

<snippet id='rating-gettingstarted-xaml'/>
<snippet id='rating-gettingstarted-csharp'/>

In addition to this you need to add the following namespace:

<snippet id='xmlns-telerikinput'/>
<snippet id='ns-telerikinput'/>

By default the control is defined in a way that five stars will be visualized and none of them will be selected. The screenshot below shows the control with selection applied:

![](images/rating_getting_started.png)

>important **SDK Browser** and **QSF** applications contain different examples that show RadRating's main features. You can find the applications in the **Examples** and **QSF** folders of your local **Telerik UI for Xamarin** installation.

## See Also

- [Key Features]({% slug rating-base %})

repository: telerik/xamarin-forms-docs

gha_language: JavaScript

repo_name: telerik/xamarin-forms-docs


text:
# hubot-jira-lc

Will post messages when the status of an issue has changed.

## Installation

In hubot project repo, run:

`npm install hubot-jira-lc --save`

Then add **hubot-jira-lc** to your `external-scripts.json`:

```json
["hubot-jira-lc"]
```

## Sample Usage

Add the following URL as a build web hook in JIRA:

```
http://<ip>:<port>/jira?targets=room1,room2
```

To trigger this webhook on workflow transition, see this guide here: https://confluence.atlassian.com/jirakb/how-to-use-a-webhook-with-a-custom-event-779160676.html

repository: RouganStriker/hubot-jira-lc

repo_name: RouganStriker/hubot-jira-lc


text:
Zilliqa JSON-RPC API documentation. Powered by Slate.

## Overview

Zilliqa apidocs contains the documentation of all JSON-RPC methods used to interact with Zilliqa nodes in order to transact and deploy/call contracts. You may currently find support for:

- cURL
- JavaScript via [`zilliqa-js`](https://github.com/Zilliqa/Zilliqa-JavaScript-Library)
- Java via [`laksa-j`](https://github.com/FireStack-Lab/LaksaJ)
- Ruby via [`laksa-ruby`](https://github.com/FireStack-Lab/LaksaRuby)
- Go via [`gozilliqa-sdk`](https://github.com/Zilliqa/gozilliqa-sdk.git)

## Contributing to Zilliqa apidocs

### Prerequisites

You're going to need the following to contribute:

- **Linux or macOS** — Windows may work, but is unsupported.
- **Ruby, version 2.3.1 or newer**
- **Bundler** — If Ruby is already installed, but the `bundle` command doesn't work, just run `gem install bundler` in a terminal.

### Running apidocs locally

1. Fork this repository on GitHub.
2. Clone _your forked repository_ (not our original one) to your hard drive with
   ```shell
   git clone https://github.com/Zilliqa/apidocs.git && cd apidocs
   ```
3. Initialize and start Slate. You can either do this locally, or with Vagrant:

   ```shell
   # either run this to run locally
   bundle install
   bundle exec middleman server

   # OR run this to run with vagrant
   vagrant up
   ```

You can now see the docs at http://localhost:4567.

### Contributing guidelines

- Learn more about editing Slate markdown [**HERE**](https://github.com/lord/slate/wiki/Markdown-Syntax).
- Please adhere to the [**Code of Conduct**](./CODE_OF_CONDUCT.md) when participating in the Zilliqa community.
- Please utilise the [**PR template**](./.github/PULL_REQUEST_TEMPLATE.md) when submitting Pull Requests to this repository.

repository: Zilliqa/apidocs

repo_name: Zilliqa/apidocs


text:
#### Playbooks
##### SolarStorm and SUNBURST Hunting and Response Playbook
Expanded hunting and mitigation with Azure.

##### New: SolarStorm Activity Behavior Hunting playbook
This manual playbook helps you to discover SolarStorm activity behavior .

Sources:
- https://www.fireeye.com/blog/threat-research/2020/12/evasive-attacker-leverages-solarwinds-supply-chain-compromises-with-sunburst-backdoor.html
- https://unit42.paloaltonetworks.com/fireeye-solarstorm-sunburst/3/
- https://www.splunk.com/en_us/blog/security/sunburst-backdoor-detections-in-splunk.html (Available from Cortex XSOAR 5.5.0).

repository: demisto/content

gha_language: Python

repo_name: demisto/content


text:
---
layout: post
title: 36. Valid Sudoku
category: [Leetcode]
description:
keywords: ['Hash Table', 'Leetcode', 'Medium']
---
### [36. Valid Sudoku](https://leetcode.com/problems/valid-sudoku)

#### Tags: 'Hash Table'

Determine if a 9x9 Sudoku board is valid. Only the filled cells need to be validated according to the following rules:

Each row must contain the digits 1-9 without repetition.

Each column must contain the digits 1-9 without repetition.

Each of the 9 3x3 sub-boxes of the grid must contain the digits 1-9 without repetition.

A partially filled sudoku which is valid.

The Sudoku board could be partially filled, where empty cells are filled with the character '.'.

Example 1:

Input:
[
  ["5","3",".",".","7",".",".",".","."],
  ["6",".",".","1","9","5",".",".","."],
  [".","9","8",".",".",".",".","6","."],
  ["8",".",".",".","6",".",".",".","3"],
  ["4",".",".","8",".","3",".",".","1"],
  ["7",".",".",".","2",".",".",".","6"],
  [".","6",".",".",".",".","2","8","."],
  [".",".",".","4","1","9",".",".","5"],
  [".",".",".",".","8",".",".","7","9"]
]
Output: true

Example 2:

Input:
[
  ["8","3",".",".","7",".",".",".","."],
  ["6",".",".","1","9","5",".",".","."],
  [".","9","8",".",".",".",".","6","."],
  ["8",".",".",".","6",".",".",".","3"],
  ["4",".",".","8",".","3",".",".","1"],
  ["7",".",".",".","2",".",".",".","6"],
  [".","6",".",".",".",".","2","8","."],
  [".",".",".","4","1","9",".",".","5"],
  [".",".",".",".","8",".",".","7","9"]
]
Output: false
Explanation: Same as Example 1, except with the 5 in the top left corner being
    modified to 8. Since there are two 8's in the top left 3x3 sub-box, it is invalid.

Note:

A Sudoku board (partially filled) could be valid but is not necessarily solvable.

Only the filled cells need to be validated according to the mentioned rules.

The given board contain only digits 1-9 and the character '.'.

The given board size is always 9x9.

### Solution
$O(n) O(n)$

可以用array 代替hashmap， 如果key数值是固定范围
```java
public boolean isValidSudoku(char[][] board) {
    // memorization using hashmap<index, count> for
    // row 1-9 column1-9 box1-9
    int[][] rows = new int[9][9];
    int[][] columns = new int[9][9];
    int[][] boxes = new int[9][9];

    for (int i = 0; i < 9; i++) {
        for (int j = 0; j < 9; j++) {
            if (board[i][j] != '.') {
                int n = Character.getNumericValue(board[i][j]) - 1;
                int box_index = i/3 * 3 + j/3;
                rows[i][n] = rows[i][n] + 1;
                columns[j][n] = columns[j][n] + 1;
                boxes[box_index][n] = boxes[box_index][n] + 1;

                if (rows[i][n] > 1 || columns[j][n] > 1 || boxes[box_index][n] > 1) {
                    return false;
                }
            }

        }
    }
    return true;
}
```


text:
In any code that seriously uses time, such as billing or scheduling code,
best software engineering practices are that you should not directly
access the operating system time. This module provides you with code to
implement that principle in Go.

See some discussions:

* [blog.plover.com's Moonpig discussion](http://blog.plover.com/prog/Moonpig.html#testing-sucks)
* [Jon Skeet's discussion on Stack Overflow](http://stackoverflow.com/questions/5622194/time-dependent-unit-tests/5622222#5622222)
* [Jim McBeath's post](http://jim-mcbeath.blogspot.com/2009/02/unit-testing-with-dates-and-times.html)

This module is fully covered with
[godoc](http://godoc.org/github.com/thejerf/abtime), including examples,
usage, and everything else you might expect from a README.md on GitHub.
(DRY.)

This is at least beta quality now, and if you're thinking about using it,
bear in mind that what it really offers is a structure, not a huge pile of
code. Should the code turn out incorrect, it would be easy for you to fix.

repository: barracudanetworks/abtime

repo_name: barracudanetworks/abtime


text:
# Visible Bin Scene Maker

## Video
[![Video(YouTube)](https://img.youtube.com/vi/ErmTTtZD8uk/0.jpg)](https://youtu.be/ErmTTtZD8uk)

## Abstract
A poster in ROBOMECH 2017, "Development of program for generating pointcloud of bin scene using physical simulation and perspective camera model," introduces this programs.
These programs help to construct 3D recognition algorithms for the bin picking based on the 3D pointcloud.

This application constructed by two programs which are BinSceneMaker and VisibleSceneMaker.
We use [Point Cloud Library(PCL)](http://pointclouds.org/) for pointcloud processing and [Bullet Physics](http://bulletphysics.org/wordpress/) for physics simulation.

## License

The license of these programs is MIT License.
Please use follows as your references.

> Naoya Chiba and Koichi Hashimoto. "Development of program for generating pointcloud of bin scene using physical simulation and perspective camera model." The Robotics and Mechatronics Conference 2017(ROBOMECH 2017), 2A2-O09, Fukushima, May, 12th, 2017.

> 千葉 直也，橋本 浩一．物理シミュレーションと透視投影カメラモデルを用いたバラ積みシーン点群生成プログラムの開発．ロボティクス・メカトロニクス講演会2017(ROBOMECH 2017)，2A2-O09，福島，5月12日，2017．

repository: gachiemchiep/visibleBinSceneMaker

repo_name: gachiemchiep/visibleBinSceneMaker


text:
## 1. What does the component do?
* Structured display of data within a table.

## 2. When should the component be used?
* It is used for displaying data, not for structuring content.
* Tables should be structured so that they grow vertically (lines) when data sets are added.

## 3. Rules
* Table cells may contain just information (e.g. text, person, status display, icon) or interaction elements (e.g. text field, select, button).
* Every column must have a header (including text or icon).
* Headers can contain subtitles in addition to the title.
* Header and line content may be left-aligned, right-aligned or centred within the table cell: Text left-aligned, icons centred, numbers right-aligned
* Units of measurement in content are ideally entered on the second line of the column header. Alternatively, they can appear directly next to the column header name in round brackets.
* Horizontal scrolling should be avoided as far as possible.
* Columns can be put into logical groups. There is no dividing line between grouped columns.
* Large amounts of data can be divided up using [Pagination](https://digital.sbb.ch/en/webapps/components/pagination). Alternatively, infinite scrolling can be used if required.
* Keyboard operation: between the lines can be navigated using the arrow keys (up, down).

## 4. Variants and statuses
The component has the following statuses:
* Default
* Hover
* Active

### 4.1 Standard
![Image of the table component in the standard variant](https://raw.githubusercontent.com/sbb-design-systems/design-system-webapp-documentation/master/documentation/components/table/images/Table_Default.png 'class: image')

#### Design specification
* [Default](https://www.sketch.com/s/36ab4f9f-f7f8-436e-9d7e-0f2088e52e04/a/L0b3V3y#Inspector)

#### Code specification
* [SBB Angular Component Library](https://angular.app.sbb.ch/angular/components/table?variant=lean)

### 4.2 Sortable
This variant has the following statuses:
* Unsorted
* Sorted

![Image of the table component in the variant sortable](https://raw.githubusercontent.com/sbb-design-systems/design-system-webapp-documentation/master/documentation/components/table/images/Table_Sortable.png 'class: image')

#### Design specification
* [Default](https://www.sketch.com/s/36ab4f9f-f7f8-436e-9d7e-0f2088e52e04/a/7yV3j3Y#Inspector)

#### Code specification
* [SBB Angular Component Library](https://angular.app.sbb.ch/angular/components/table?variant=lean)

### 4.3 Groupable
![Image of the table component in the variant groupable](https://raw.githubusercontent.com/sbb-design-systems/design-system-webapp-documentation/master/documentation/components/table/images/Table_Groupable.png 'class: image')

#### Design specification
* [Default](https://www.sketch.com/s/36ab4f9f-f7f8-436e-9d7e-0f2088e52e04/a/ygLDjDq#Inspector)

#### Code specification
* [SBB Angular Component Library](https://angular.app.sbb.ch/angular/components/table?variant=lean)

### 4.4 Selectable
This variant has the following statuses:
* Unselected
* EntrySelected
* AllSelected

![Image of the table component in the variant selectable](https://raw.githubusercontent.com/sbb-design-systems/design-system-webapp-documentation/master/documentation/components/table/images/Table_Selectable.png 'class: image')

#### Design specification
* [Default](https://www.sketch.com/s/36ab4f9f-f7f8-436e-9d7e-0f2088e52e04/a/9P53z3p#Inspector)

#### Code specification
* [SBB Angular Component Library](https://angular.app.sbb.ch/angular/components/table?variant=lean)

### 4.5 Filterable
This variant has the following statuses:
* Unfiltered
* Filtered

![Image of the table component in the variant filterable](https://raw.githubusercontent.com/sbb-design-systems/design-system-webapp-documentation/master/documentation/components/table/images/Table_Filterable.png 'class: image')

* The individual columns can be filtered according to content type (text, date, value, etc.) using the appropriate components  ([Textfield](https://digital.sbb.ch/en/webapps/components/textfield), [Datepicker](https://digital.sbb.ch/en/webapps/components/datepicker), [Select](https://digital.sbb.ch/en/webapps/components/select), etc.).
* A separate [filter](https://digital.sbb.ch/en/webapps/modules/filter) can also be used to restrict large amounts of data.
* It is advisable to display the number of filtered items to the users, e.g. "34 out of 3890".

#### Design specification
* [Default](https://www.sketch.com/s/36ab4f9f-f7f8-436e-9d7e-0f2088e52e04/a/PGRjqjP#Inspector)

#### Code specification
* [SBB Angular Component Library](https://angular.app.sbb.ch/angular/components/table?variant=lean)

### 4.6 Inline actions
![Image of the table component in the variant with inline actions](https://raw.githubusercontent.com/sbb-design-systems/design-system-webapp-documentation/master/documentation/components/table/images/Table_Inline_Actions.png 'class: image')

* When hovering over rows or focusing them using tab navigation via the keyboard, actions can be offered on the elements.
* The actions are offered by using [Icon button](https://digital.sbb.ch/en/webapps/components/button). Depending on the use case, it is decided in which column (first or last column) they are placed. There they overlay the existing content.
* A maximum of 3 actions should be offered. If more are needed, a [Contextmenu](https://digital.sbb.ch/en/webapps/components/contextmenu) should be used.
* Keyboard operation: if the focus is on a row in the table, it's possible to navigate to the actions using 'Tab'-key of the keyboard.

#### Design specification
* [Default](https://www.sketch.com/s/36ab4f9f-f7f8-436e-9d7e-0f2088e52e04/a/g07K3Ka#Inspector)

#### Code specification
* [SBB Angular Component Library](https://angular.app.sbb.ch/angular/components/table?variant=lean)

### 4.7 Batch actions
![Image of the table component in the variant with batch actions](https://raw.githubusercontent.com/sbb-design-systems/design-system-webapp-documentation/master/documentation/components/table/images/Table_Batch_Actions.png 'class: image')

* Batch actions can be offered on selection of (multiple) elements.
* All versions of [Buttons](https://digital.sbb.ch/en/webapps/components/button) can be used for the actions.
* The primary action is on the left, the secondary actions are on the right.
* A maximum of 3 actions should be offered. If more are needed, a [Contextmenu](https://digital.sbb.ch/en/webapps/components/contextmenu) should be used.
* The batch actions are placed above the table on the right.

#### Design specification
* [Default](https://www.sketch.com/s/36ab4f9f-f7f8-436e-9d7e-0f2088e52e04/a/zxl7l35#Inspector)

#### Code specification
* [SBB Angular Component Library](https://angular.app.sbb.ch/angular/components/table?variant=lean)

## 5. Example application
![Image of an example of a table with sorting, selection, filtering, paging and batch actions](https://raw.githubusercontent.com/sbb-design-systems/design-system-webapp-documentation/master/documentation/components/table/images/Table_Showcase.png 'class: image')


text:
# Sensor Fusion Self-Driving Car Course

### Welcome to the Sensor Fusion course for self-driving cars.

In this course we will be talking about sensor fusion, whch is the process of taking data from multiple sensors and combining it to give us a better understanding of the world around us. we will mostly be focusing on two sensors, lidar, and radar. By the end we will be fusing the data from these two sensors to track multiple cars on the road, estimating their positions and speed.

**Lidar** sensing gives us high resolution data by sending out thousands of laser signals. These lasers bounce off objects, returning to the sensor where we can then determine how far away objects are by timing how long it takes for the signal to return. Also we can tell a little bit about the object that was hit by measuring the intesity of the returned signal. Each laser ray is in the infrared spectrum, and is sent out at many different angles, usually in a 360 degree range. While lidar sensors gives us very high accurate models for the world around us in 3D, they are currently very expensive, upwards of $60,000 for a standard unit.

**Radar** data is typically very sparse and in a limited range, however it can directly tell us how fast an object is moving in a certain direction. This ability makes radars a very pratical sensor for doing things like cruise control where its important to know how fast the car infront of you is traveling. Radar sensors are also very affordable and common now of days in newer cars.

**Sensor Fusion** by combing lidar's high resoultion imaging with radar's ability to measure velocity of objects we can get a better understanding of the sorrounding environment than we could using one of the sensors alone.

## Installation

### Ubuntu

https://askubuntu.com/questions/916260/how-to-install-point-cloud-library-v1-8-pcl-1-8-0-on-ubuntu-16-04-2-lts-for

### Windows

http://www.pointclouds.org/downloads/windows.html

### MAC

http://www.pointclouds.org/downloads/macosx.html
http://www.pointclouds.org/documentation/tutorials/installing_homebrew.php

## RUN

## TODO

- [ ] Clean up code
- [ ] Add configuration file
- [ ] Docker image
- [ ] Better plane segmentation algorithm
- [ ] Better clustering algorithm: DBSCAN
- [ ] PointNet
- [ ] PCA

## References

1. [基于欧几里德聚类的激光雷达点云分割及ROS实现](https://blog.csdn.net/AdamShan/article/details/83015570)

repository: woo-soojin/lidar-object-detection

repo_name: woo-soojin/lidar-object-detection


text:
# LaTeX Thai Enumeration Package

This `thaifont-setup` LaTeX package provides an alternative way to set up font
environment settings in complement to another package
[fonts-tlwg](https://github.com/tlwg/fonts-tlwg/). It relies on the font
definition files (`*.fd`) in the most recent update of
[fonts-tlwg version 0.6.4](https://github.com/tlwg/fonts-tlwg/tree/v0.6.4).

## Usage

For now, see the source code [thaienum.tex](thaienum.tex) to get started.
More updates are coming.

## Package maintenance

The author and maintainer of this package is Abhabongse Janthong. Anything
regardling this package such as bug report or suggestions should be reported
via GitHub at https://github.com/abhabongse/latex-thai-utils/issues.

Please note that this is a preliminary release, so it is not yet a mature
LaTeX package. The support for this package may be dropped at any time.

## License

This package, which includes all files in this directory, is released under
the [LaTeX project public license (LPPL), version 1.3c](https://www.latex-project.org/lppl/lppl-1-3c/).

repository: abhabongse/latex-thai-utils

repo_name: abhabongse/latex-thai-utils


text:
# Body Parsing

Pode has inbuilt body/payload parsing on Requests, which by default can parse the following content types:

* `*/json`
* `*/xml`
* `*/csv`
* `*/x-www-form-urlencoded`
* `multipart/form-data`

This is useful however, there can be times when you might want to use a different JSON parsing library - or parse a completely different content type altogether! This is possible using the [`Add-PodeBodyParser`](../../../../Functions/Middleware/Add-PodeBodyParser) function.

## Adding a Parser

You can use the [`Add-PodeBodyParser`](../../../../Functions/Middleware/Add-PodeBodyParser) function to define a scriptblock that can parse the Request body for a specific content type. Any set parsers have a higher priority than the inbuilt ones, meaning if you define a parser for `application/json` then this will be used instead of the inbuilt one.

The scriptblock you supply will be supplied a single argument, which will be the Body of the Request.

For example, to set your own JSON parser that will simply return the body unmodified you could do the following:

```powershell
Add-PodeBodyParser -ContentType 'application/json' -ScriptBlock {
    param($body)
    return $body
}
```

This can then be accessed the normal way within a Route from the `.Data` object on the supplied event:

```powershell
Add-PodeRoute -Method Post -Path '/' -ScriptBlock {
    param($e)

    # if using the above parser, .Data here will just be a plain string
    Write-PodeTextResponse -Value $e.Data
}
```

This is great if you want to be able to parse other content types like YAML, HCL, or many others!

## Removing a Parser

To remove a defined parser you can use the [`Remove-PodeBodyParser`](../../../../Functions/Middleware/Remove-PodeBodyParser) function:

```powershell
Remove-PodeBodyParser -ContentType 'application/json'
```

!!! note
    This will only remove defined custom parsers, and will not affect the inbuilt parsers.

repository: Jaykul/Pode

repo_name: Jaykul/Pode


text:
# new-object

Creates an Object from a collection of key-value pairs or key-descriptor pairs.

The [`Map`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map) constructor lets you specify initial keys and values via an `iterable` collection (e.g. an array) of key-value pairs, whereas the `Object` constructor does not. This module fills that gap, approximating [the ECMA-defined behavior for the Map constructor](https://tc39.github.io/ecma262/#sec-map-iterable) but for Objects. (Remember that, unlike Maps, Objects can only use strings and symbols as keys.) In its simplest mode, you can think of the `new-object` module as doing the opposite of [`Object.entries()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries):

```JavaScript
newObject(Object.entries({a: 1, b: 2})) // {a: 1, b: 2}
```

But in addition — since we’re working with Objects instead of Maps — `new-object` lets you customize the property definitions on the new object.

```JavaScript
newObject(Object.entries({a: 1, b: 2}), {descDefaults: {writable: false}}) // {a: 1, b: 2}
```

## Installation

Requires [Node.js](https://nodejs.org/) 8.3.0 or above.

```bash
npm i new-object
```

## API

The module exports a single function.

### Parameters

1. `entries` (iterable or other object): This must be one of the following:
    * An array (or other iterable) of key-value pairs for the object.
    * An array (or other iterable) of key-descriptor pairs for the object’s properties (if `descs` is set to `true`).
    * An object whose values are property descriptors for the new object.
2. Optional: Object argument:
    * `descDefaults` (plain object): A collection of descriptor settings (namely, `configurable`, `enumerable`, and/or `writable`) that will be applied to every property created on the new object. If you would like all these settings to be undefined, provide an empty object. Omit this option if you have specified complete descriptors in `entries` or if you want the module to use simple assignment. If you provided property descriptors in `entries`, the contents of `descDefaults` will serve as default values for those descriptors. If you specify `writable` in `descDefaults`, it will be automatically skipped for descriptors that contain getters or setters, since such descriptors cannot contain `writable`.
    * `descs` (boolean): Used to disambiguate the purpose of the values in `entries`. If set to `true`, the values in `entries` will be interpreted as property descriptor objects. If set to `false`, the values in `entries` will be used as values for the new object. Defaults to `false` if `entries` is an iterable; defaults to `true` if `entries` is a non-iterable object.
    * `throwIfEquivKeys` (Error, string, or boolean): Set this to throw an error if `entries` contains keys that would be considered duplicates in the context of an object. For example, a Map can have keys that are objects, but those keys will all likely evaluate to `[object Object]` and overwrite each other if made keys in an object. Similarly, a Map can have distinct `1` (number) and `'1'` (string) keys, but these would be considered the same in an object context. If such a conflict exists and if this option is set to an Error object, the provided Error will be thrown as-is. An error message string will be used to construct a `TypeError`. A value of `true` will throw a `TypeError` with a default error message. A value of `false` is the same as the default behavior, which is that later equivalent keys will silently overwrite the earlier ones.

### Return Value

Returns a plain object built with `entries`.

## Examples

### Array of Key-Value Pairs

This is the simplest use of the module, which is essentially performs the operation opposite that of [`Object.entries()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/entries).

```javascript
const newObject = require('new-object')

const entries = [['a', 1], ['b', 2]]

// What was possible for a Map...
const map = new Map(entries)
map.get('a') // 1

// ...is now also possible for an Object:
const obj = newObject(entries)
obj.a // 1
```

### Array of Key-Value Pairs With Global Descriptor Settings

This example creates the same object as above, but with read-only properties. Read more about property descriptor settings at [`Object.defineProperty()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty).

```javascript
const newObject = require('new-object')

const obj = newObject(
  [['a', 1], ['b', 2]],
  {descDefaults: {writable: false}}
)

obj.a // 1
obj.b // 2

obj.a = 123 // TypeError: Cannot set property a of #<Object> which has only a getter
```

### Array of Key-Descriptor Pairs

In addition to providing an array of key-value pairs as in the two examples above, you can also provide an array of keys paired with object property descriptors, if `descs` is set to `true`. Read more about property descriptor settings at [`Object.defineProperty()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty).

```javascript
const newObject = require('new-object')

const obj = newObject([
  ['a', {get: () => 1}],
  ['b', {get: () => 2}],
], {descs: true})

obj.a // 1
obj.b // 2

obj.a = 123 // TypeError: Cannot set property a of #<Object> which has only a getter
```

### Object of Key-Descriptor Pairs

You can also do the same as above but with an object. An object is presumed to contain descriptors (if it contains values, why do you need this module again?), so you don’t need to set `descs` to `true`.

```javascript
const newObject = require('new-object')

const obj = newObject({
  a: {get: () => 1},
  b: {get: () => 2},
})

obj.a // 1
obj.b // 2
```

### Supplementing Descriptors with Default Settings

Whenever you’re using the module in a property descriptor mode, you can specify settings to be applied to all property descriptors using `descDefaults`.

```javascript
const newObject = require('new-object')

const obj = newObject([
  ['a', {get: () => 1}], // `writable` (below) will be ignored for this property
  ['b', {value: 2}],
], {
  descs: true, // We have to specify this because the entries are in an array
  descDefaults: {configurable: true, writable: true},
})
```

Since trying to set `writable` in a descriptor that also specifies a getter or setter will throw an error, the module will ignore the value of `writable` in `descDefaults` when creating the descriptor for a get/set property, such as the `a` property in the example above.

## Version Migration Guide

Here are backward-incompatible changes you need to know about.

### 3.x ⇒ 4.x

* The minimum supported Node version is now 8.3.0 (instead of 6.0.0).

## Related

* [construct-map](https://github.com/lamansky/construct-map): Turns key-value pairs into a collection of the same type as another value, such as Map or Object.
* [def-props](https://github.com/lamansky/def-props): Same as this module, but modifies a existing object instead of creating a new one.


text:
---
type: rule
archivedreason:
title: SharePoint Rules Categories - Do You Know How to Make the Title Consistent?
guid: e3d6149d-b648-4229-bf9c-8b7a051266e5
uri: sharepoint-rules-categories-do-you-know-how-to-make-the-title-consistent
created: 2010-11-02T07:37:42.0000000Z
authors:
- title: Adam Cogan
  url: https://ssw.com.au/people/adam-cogan
- title: Cameron Shaw
  url: https://ssw.com.au/people/cameron-shaw
- title: William Yin
  url: https://ssw.com.au/people/william-yin
related: []
redirects: []

---

When you want to update the Rule Title, please DO NOT update them in the list directly.
  Click the URL near it, navigate to the Rule Summary page, and edit the Rule Summary Page Title, it will automatically update:

* Rule Summary Page Title
* Site Title
* Item Title in RuleCategoryLookupData List

<!--endintro-->
 Like this (thanks for Adam's snapshot) :
![](SPTitle.jpg)


text:
# Changelog

## 16.07.2018 `3bac827`

Change github option for `biodynamo new`. Previously it was opt-out (`--no-github`).
This commit changes it to opt-in (`--github`).

| Old                                 | New                                    |
| ----------------------------------- | -------------------------------------- |
| `biodynamo new --no-github`         | `biodynamo new` |
| `biodynamo new`                     | `biodynamo new --github` |

## 11.07.2018 `82e7e15`

* Add `biodynamo demo` command to try out the demos
`biodynamo demo` lists all the available demos
`biodynamo demo <demo-name> <dir>` sets up the demo `<demo-name>` in directory `<dir>`.
If `<dir>` is not specified, it defaults to the current working directory.

## 26.06.2018 `ba4fe1f`

* Add support for multiple simulations per process. Only one simulation
can be active at the same time. Introduces new class `Simulation` (see [API](https://biodynamo.github.io/api/structbdm_1_1Simulation.html)).
This change causes many API changes -- see subsection below.

* Write simulation files to separate directory: `output/simulation-id/`

* Integrate simulation template for `biodynamo new` into the biodynamo repository to avoid
inconsistencies with the biodynamo version.

### API changes

| Old                                 | New                                    |
| ----------------------------------- | -------------------------------------- |
| `InitializeBioDynaMo(...)`          | `Simulation<> simulation(...)` |
| `Rm()`
 `TRm::Get()`
  `TResourceManager::Get()` | `auto* rm = simulation.GetResourceManager();` |
| `GetDiffusionGrid(...)`             | `rm->GetDiffusionGrid(...)` |
| `Grid::GetInstance()`               | `auto* grid = simulation.GetGrid();` |
| `Param::some_parameter_;`           | `auto* param = simulation.GetParam();`
 `param->some_parameter_;` |

repository: aliendr/biodynamo

repo_name: aliendr/biodynamo


text:
# decaffeinate

CoffeeScript in, modern JavaScript out.

JavaScript is the future, in part thanks to CoffeeScript. Now that it has served
its purpose, it's time to move on. Convert your CoffeeScript source to modern
JavaScript with decaffeinate.

## Install

```
$ npm install -g decaffeinate
```

To use the development version of decaffeinate, use the `@dev` tag:

```
$ npm install -g decaffeinate@dev
```

The dev version is based on the `master` branch and may be incomplete or broken.

## Status

**Incomplete.** Check the [issues] page for outstanding bugs and incomplete
features. This project should not yet be relied upon for production use.

## Goals

* Fully automated conversion of the CoffeeScript language to modern JavaScript.
* Preserve whitespace, formatting, and comments as much as possible to allow
  a full one-time conversion of your CoffeeScript source code.
* Provide helpful error messages when it encounters an unsupported language
  construct.

## Usage

See the output of `decaffeinate --help` after installing.

<hr>

[issues]: https://github.com/decaffeinate/decaffeinate/issues

repository: mikekono/decaffeinate

repo_name: mikekono/decaffeinate


text:
## osx-wifi-cli
### A command line tool for managing wifi connections on OSX

* * *
#### Installation
```bash
$ npm install -g osx-wifi-cli
```
* * *
#### Usage

`osx-wifi-cli` shows you which network you are connected to, if you are.

`osx-wifi-cli scan` shows available networks.

`osx-wifi-cli on`, `osx-wifi-cli off`, and `osx-wifi-cli restart` control the wifi device state.

`osx-wifi-cli NETWORK PASSWORD` tries to connects to NETWORK with PASSWORD.

* * *
#### Notes
* This has been so far developed to "Work on my machine". If it's not working on yours, please tell me what's up, and I'll try to fix it. (For instance, wifi device is assumed to be en0).
* For easier execution, add to your `.bashrc` file: `alias wifi='osx-wifi-cli'`
* This was developed in a way that should make implementing this for other operating systems easy. If you want to give it a shot, check out the code or send me a message.

* * *
#### TODOs
* Enable connection to a network without a password. (Should currently be possible with `" "`)
* Enable picking a network by a numeric id

* * *
#### Feedback
* If you enjoyed this tool, please star it on Github!
* I'd love to get any feedback you might have! Mail me at<EMAIL_ADDRESS>or [open an issue](https://github.com/danyshaanan/osx-wifi-cli/issues/new).
* More material appreciation is welcome in the form of bitcoins. My address can be found on [this page](http://danyshaanan.com/bitcoin).

repository: wraithan/osx-wifi-cli

repo_name: wraithan/osx-wifi-cli


text:
# Path Parameters

You can declare path "parameters" or "variables" with the same syntax used by Python format strings:

```Python hl_lines="6-7"
{!../../../docs_src/path_params/tutorial001.py!}
```

The value of the path parameter `item_id` will be passed to your function as the argument `item_id`.

So, if you run this example and go to <a href="http://<IP_ADDRESS>:8000/items/foo" class="external-link" target="_blank">http://<IP_ADDRESS>:8000/items/foo, you will see a response of:

```JSON
{"item_id":"foo"}
```

## Path parameters with types

You can declare the type of a path parameter in the function, using standard Python type annotations:

```Python hl_lines="7"
{!../../../docs_src/path_params/tutorial002.py!}
```

In this case, `item_id` is declared to be an `int`.

!!! check
    This will give you editor support inside of your function, with error checks, completion, etc.

## Data conversion

If you run this example and open your browser at <a href="http://<IP_ADDRESS>:8000/items/3" class="external-link" target="_blank">http://<IP_ADDRESS>:8000/items/3, you will see a response of:

```JSON
{"item_id":3}
```

!!! check
    Notice that the value your function received (and returned) is `3`, as a Python `int`, not a string `"3"`.

    So, with that type declaration, **FastAPI** gives you automatic request "parsing".

## Data validation

But if you go to the browser at <a href="http://<IP_ADDRESS>:8000/items/foo" class="external-link" target="_blank">http://<IP_ADDRESS>:8000/items/foo, you will see a nice HTTP error of:

```JSON
{
    "detail": [
        {
            "loc": [
                "path",
                "item_id"
            ],
            "msg": "value is not a valid integer",
            "type": "type_error.integer"
        }
    ]
}
```

because the path parameter `item_id` had a value of `"foo"`, which is not an `int`.

The same error would appear if you provided a `float` instead of an `int`, as in: <a href="http://<IP_ADDRESS>:8000/items/4.2" class="external-link" target="_blank">http://<IP_ADDRESS>:8000/items/4.2

!!! check
    So, with the same Python type declaration, **FastAPI** gives you data validation.

    Notice that the error also clearly states exactly the point where the validation didn't pass.

    This is incredibly helpful while developing and debugging code that interacts with your API.

## Documentation

And when you open your browser at <a href="http://<IP_ADDRESS>:8000/docs" class="external-link" target="_blank">http://<IP_ADDRESS>:8000/docs, you will see an automatic, interactive, API documentation like:

!!! check
    Again, just with that same Python type declaration, **FastAPI** gives you automatic, interactive documentation (integrating Swagger UI).

    Notice that the path parameter is declared to be an integer.

## Standards-based benefits, alternative documentation

And because the generated schema is from the OpenAPI standard, there are many compatible tools.

Because of this, **FastAPI** itself provides an alternative API documentation (using ReDoc), which you can access at <a href="http://<IP_ADDRESS>:8000/redoc" class="external-link" target="_blank">http://<IP_ADDRESS>:8000/redoc:

The same way, there are many compatible tools. Including code generation tools for many languages.

## Pydantic

All the data validation is performed under the hood by Pydantic, so you get all the benefits from it. And you know you are in good hands.

You can use the same type declarations with `str`, `float`, `bool` and many other complex data types.

Several of these are explored in the next chapters of the tutorial.

## Order matters

When creating *path operations*, you can find situations where you have a fixed path.

Like `/users/me`, let's say that it's to get data about the current user.

And then you can also have a path `/users/{user_id}` to get data about a specific user by some user ID.

Because *path operations* are evaluated in order, you need to make sure that the path for `/users/me` is declared before the one for `/users/{user_id}`:

```Python hl_lines="6  11"
{!../../../docs_src/path_params/tutorial003.py!}
```

Otherwise, the path for `/users/{user_id}` would match also for `/users/me`, "thinking" that it's receiving a parameter `user_id` with a value of `"me"`.

Similarly, you cannot redefine a path operation:

```Python hl_lines="6  11"
{!../../../docs_src/path_params/tutorial003b.py!}
```

The first one will always be used since the path matches first.

## Predefined values

If you have a *path operation* that receives a *path parameter*, but you want the possible valid *path parameter* values to be predefined, you can use a standard Python `Enum`.

### Create an `Enum` class

Import `Enum` and create a sub-class that inherits from `str` and from `Enum`.

By inheriting from `str` the API docs will be able to know that the values must be of type `string` and will be able to render correctly.

Then create class attributes with fixed values, which will be the available valid values:

```Python hl_lines="1  6-9"
{!../../../docs_src/path_params/tutorial005.py!}
```

!!! info
    Enumerations (or enums) are available in Python since version 3.4.

!!! tip
    If you are wondering, "AlexNet", "ResNet", and "LeNet" are just names of Machine Learning models.

### Declare a *path parameter*

Then create a *path parameter* with a type annotation using the enum class you created (`ModelName`):

```Python hl_lines="16"
{!../../../docs_src/path_params/tutorial005.py!}
```

### Check the docs

Because the available values for the *path parameter* are predefined, the interactive docs can show them nicely:

### Working with Python *enumerations*

The value of the *path parameter* will be an *enumeration member*.

#### Compare *enumeration members*

You can compare it with the *enumeration member* in your created enum `ModelName`:

```Python hl_lines="17"
{!../../../docs_src/path_params/tutorial005.py!}
```

#### Get the *enumeration value*

You can get the actual value (a `str` in this case) using `model_name.value`, or in general, `your_enum_member.value`:

```Python hl_lines="20"
{!../../../docs_src/path_params/tutorial005.py!}
```

!!! tip
    You could also access the value `"lenet"` with `ModelName.lenet.value`.

#### Return *enumeration members*

You can return *enum members* from your *path operation*, even nested in a JSON body (e.g. a `dict`).

They will be converted to their corresponding values (strings in this case) before returning them to the client:

```Python hl_lines="18  21  23"
{!../../../docs_src/path_params/tutorial005.py!}
```

In your client you will get a JSON response like:

```JSON
{
  "model_name": "alexnet",
  "message": "Deep Learning FTW!"
}
```

## Path parameters containing paths

Let's say you have a *path operation* with a path `/files/{file_path}`.

But you need `file_path` itself to contain a *path*, like `home/johndoe/myfile.txt`.

So, the URL for that file would be something like: `/files/home/johndoe/myfile.txt`.

### OpenAPI support

OpenAPI doesn't support a way to declare a *path parameter* to contain a *path* inside, as that could lead to scenarios that are difficult to test and define.

Nevertheless, you can still do it in **FastAPI**, using one of the internal tools from Starlette.

And the docs would still work, although not adding any documentation telling that the parameter should contain a path.

### Path convertor

Using an option directly from Starlette you can declare a *path parameter* containing a *path* using a URL like:

```
/files/{file_path:path}
```

In this case, the name of the parameter is `file_path`, and the last part, `:path`, tells it that the parameter should match any *path*.

So, you can use it with:

```Python hl_lines="6"
{!../../../docs_src/path_params/tutorial004.py!}
```

!!! tip
    You could need the parameter to contain `/home/johndoe/myfile.txt`, with a leading slash (`/`).

    In that case, the URL would be: `/files//home/johndoe/myfile.txt`, with a double slash (`//`) between `files` and `home`.

## Recap

With **FastAPI**, by using short, intuitive and standard Python type declarations, you get:

* Editor support: error checks, autocompletion, etc.
* Data "parsing"
* Data validation
* API annotation and automatic documentation

And you only have to declare them once.

That's probably the main visible advantage of **FastAPI** compared to alternative frameworks (apart from the raw performance).

repository: samuelcolvin/fastapi

repo_name: samuelcolvin/fastapi


text:
---
layout: creature
name: "Voidling"
tags: [large, aberration, cr11, tome-of-beasts]
cha: 10 (+0)
wis: 16 (+3)
int: 14 (+2)
con: 10 (+0)
dex: 22 (+6)
str: 15 (+2)
size: Large aberration
alignment: chaotic evil
challenge: "11 (7200 XP)"
languages: "telepathy 60 ft."
skills: "Stealth +10"
senses: "truesight 60 ft., passive Perception 13"
saving_throws: "Con +4, Int +6, Wis +7, Cha +4"
damage_immunities: "necrotic"
condition_immunities: "exhaustion, petrified, prone"
speed: "0 ft., fly 50 ft. (hover)"
hit_points: "110 (20d10)"
armor_class: "16"
---

***Fed by Darkness.*** A voidling in magical darkness at the start of its turn heals 5 hit points.

***Magic Resistance.*** The voidling has advantage on saving throws against spells and other magical effects except those that cause radiant damage.

***Innate Spellcasting.*** The voidling's innate spellcasting ability is Wisdom (spell save DC 15, spell attack bonus +7). It can innately cast the following spells, requiring no material components:

At will: darkness, detect magic, fear

3/day each: eldritch blast (3 beams), black tentacles

1/day each: phantasmal force, reverse gravity

***Natural Invisibility.*** A voidling in complete darkness is considered invisible to creatures that rely on normal vision or darkvision.

### Actions

***Multiattack.*** The voidling makes 4 tendril attacks.

***Tendril.*** Melee Weapon Attack: +10 to hit, reach 10 ft., one target. Hit: 10 (1d8 + 6) slashing damage plus 11 (2d10) necrotic damage.

***Necrotic Burst (Recharge 5-6).*** The voidling releases a burst of necrotic energy in a 20-foot radius sphere centered on itself. Those in the area take 35 (10d6) necrotic damage, or half damage with a successful DC 17 Constitution saving throw.


text:
[//]: # (Image References)
[image_0]: ./misc/rover_image.jpg
[![Udacity - Robotics NanoDegree Program](https://s3-us-west-1.amazonaws.com/udacity-robotics/Extra+Images/RoboND_flag.png)](https://www.udacity.com/robotics)
# Project: Deep Learning

### Network Architecture
The network architecture is shown in the following figure:

![network](misc/network.jpg)

A fully convolutional neural network described in the lectures is used for the segmentation task. The network consists of three encoder modules, a 1x1 convolution layer, three decoder modules and a softmax output layer with three channels. Each output channel represents a segmentation class, i.e., hero, people or background. Each encoder module includes a number of convolution maps with separable kernels followed by a batch normalization layer. Each decoder layer consists of bilinear upsampling layer concatenated with the encoder module inputs (skip connections) followed by convolution maps with stride of one.

The 1x1 convolutional layer is used instead of fully-connected layer right after the encoder to preserve spatial information which is needed for a segmentation task while learning semantics similar to a fully-connected layer. The skip connections results in a more fine-grained segmentation comparing to a decoder which only uses heavily downsampled encoder output.

The encoder modules are used to extract features from the input image using the training data, The first layers extract mostly low-level features of the images such as edges, angles etc. while the next layers extracts higher-level features such as body or face parts. The decoder modules are needed to reconstruct the high-resolution segmented output image using the semantics learned by the first layers as well as high-resolution data provided by skip connections.

The characteristics of each layer of the network is listed in the following table:

Name | Depth | Kernel Size | Strides | Separable | Batch Normalized | Activation
:----|:----|:----|:----|:----|:----|:----
input | 3 | - | - | - | - | -
x0 | 64 | 3x3 | 2 | ✓ | ✓ |relu
x1 | 64 | 3x3 | 2 | ✓ | ✓ |relu
x2 | 64 | 3x3 | 2 | ✓ | ✓ |relu
x3 | 256 | 1x1 | 1 | ✗ | ✗ |relu
x4 | 64 | 3x3 | 2 | ✓ | ✗ |relu
x5 | 64 | 3x3 | 2 | ✓ | ✗ |relu
x6 | 64 | 3x3 | 2 | ✓ | ✗ |relu
Output | 3 | 1x1 | 2 | ✗ | ✗ |softmax

The “separable kernel” choice results in a less-complicated network and faster convergence and prevents overfitting to the training data. Also, bilinear upsampling which is used instead of transpose convolution simplifies the network even while it can meet the performance requirement defined for the project.

The network parameters, such as number of layers, depth of each layer and kernel size are chosen by trial and error. If a too small network (few layers or depth per layer) is trained the training and validation losses can not be lowered by any number of epochs of training. On the other hand, a too large network might result in low training loss but the validation loss will have a high variance and the overall performance of the network is not satisfactory. Also a large network might not be fit in the GPU memory or the training will takes a lot of time to complete.

### Data Collection

Training and validation datasets are obtained using "DL Training" mode in the provided QuadSim software. A typical setup for patrol points, path points and spawn points is shown in the following picture:

![data-setup](misc/data_setup.jpg)

The data is collected from multiple places on the campus, to train the network with different variety of scene backgrounds. The validation data set is collected in the areas that no training data collected. This way we can reduce the correlation between training and validation data. 20,638 of training images and 6,443 of validation images are collected using the methods described.

Following picture shows samples of training images and the corresponding masks.

Sample Images             | Sample Masks
:-------------------------|:----------------------
![1](misc/img_grid.jpg)   | ![2](misc/msk_grid.jpg)

### Training the Deep Network

#### Training Parameters

The training parameters that are used to train the network is listed in the following table:

learning_rate | batch_size | num_epochs | steps_per_epoch | validation_steps | workers
:---|:---|:---|:---|:---|:---
0.002 | 64 | 20 | 323  | 101  | 4

The methods that are used to set the parameters are described briefly in the following:

**learning_rate**: A very small learning rate results in a slow convergence. Therefore, the learning rate is increased such that the maximum conversion rate can be achieved while the learning curves are smooth and there are no big jumps in it.

**batch_size**: A small batch size results in slow learning and noisy convergence. It is desirable to have larger batch sizes while the training batches fit into GPU memory. However, it has been observed that using a too large batch size might cause some problems in the loss convergence.

**num_epochs**: The learning epochs are continued until there is not much improvement and the performance requirements are met.

**steps_per_epoch**: is the number of training images divided by batch size.

**validation_steps**: is the number of validation images divided by batch size.

**workers**: is set according to the processing platform capabilities.

Following figure shows the learning curve of the training process. It can be seen that training and validation have a similar trend which means the the model is not over-fitting or under-fitting. Also, the validation loss is generally larger than training loss which is expected as the validation data is collected in a different area of the city.

The network weights after training is saved in `data/weights/model_weight.h5' file in HDF5 format.

![training](misc/training.png)

### Results

Following images show the sample performance of the trained network in different settings.

#### Sample output while following the target:
![following](misc/following.jpg)
#### Sample output while at patrol without target:
![no-target](misc/no_target.jpg)
#### Sample output while at patrol with target:
![target](misc/target.jpg)

The performance metrics calculated in the notebook are as following:

Final IoU: **55%**

Weighted Final IoU: **41%**

### Limitations and Future works

There are some issues with the performance of the trained network. For example, sometimes the network labels the objects with strong edges as people or hero. To resolve this issue, it might be useful to collect negative training data consisting of objects or backgrounds with heavy edges. Also, we might need to change the network architecture as the training data size increases.

A lot of imperfections and variations in a real-world application are not present in the training data. For example, the scene lighting is always the same, while in reality, we can have different levels of lighting. Also, we might have other moving objects such as animals or cars that might be labeled incorrectly by the network. Also, it seems that the network uses the color feature of hero as a main indicator which might cause problems if someone else with similar dress color shows up in front of the camera. Some of these issues can be addressed by collecting more training data of problematic scenarios and a more complex network.

repository: hmirzaei/RoboND-DeepLearning-Project

repo_name: hmirzaei/RoboND-DeepLearning-Project


text:
+++
date = 2017-01-01T00:00:00  # Schedule page publish date.

title = "‘Inward horror will be their first tormentor’: the public execution of Charles I and its impact on historians and the future"
time_start = 2017-06-19T00:00:00
time_end = 2017-06-19T01:00:00
abstract = ""
abstract_short = ""
event = "*Cruelty and Compassion: Postgraduate Conference* at the University of Leeds"
event_url = "https://www.leeds.ac.uk/arts/news/article/4970/cruelty_and_compassion"
location = "Leeds, United Kingdom"

# Is this a selected talk? (true/false)
selected = false

# Projects (optional).
#   Associate this talk with one or more of your projects.
#   Simply enter the filename (excluding '.md') of your project file in `content/project/`.
projects = ["regicide"]

# Links (optional).
url_pdf = ""
url_slides = ""
url_video = ""
url_code = ""

# Does the content use math formatting?
math = true

# Does the content use source code highlighting?
highlight = true

# Featured image
# To use, add an image named `featured.jpg/png` to your page's folder.
[image]
  # Caption (optional)
  caption = ""

  # Focal point (optional)
  # Options: Smart, Center, TopLeft, Top, TopRight, Left, Right, BottomLeft, Bottom, BottomRight
  focal_point = ""

+++


text:
# app
The slidewinder web/desktop app

## Run the app
To get the meteor app running fire up your ```terminal``` and:

```
cd slidewinder
meteor
```
Meteor will install all the packages and dependencies. This could take a minute or so. Once everything has installed, you can go see the magic at: ```http://localhost:3000```

repository: joeyklee/app

repo_name: joeyklee/app


text:
### Perfit

PERFIT is a fitting application and sizing tool for online shopping that uses body scanning to get accurate body measurements and shows the user the look and feel of the clothing on a virtual 3D model of themselves.

Alpha version: https://www.youtube.com/watch?v=X1SWGpsE3Xw

[Under Development]

repository: jaxee/perfit

gha_language: ASP

repo_name: jaxee/perfit


text:
# UIKernel

UIKernel is a lib, built in React, that deals with complex admin-panels display, which is a wrapper of CRUD model.

## Installing

npm install uikernel

## Documentation

[Link](http://uikernel.io)

repository: MaxGenash/uikernel

repo_name: MaxGenash/uikernel


text:
# [<img<EMAIL_ADDRESS>height="48" width="48" /> 1password](https://chocolatey.org/packages/1password)

1Password – Too many passwords to remember?

1Password can create strong, unique passwords for you, remember them, and restore them, all directly in your web browser.

repository: OXINARF/chocolatey-coreteampackages

repo_name: OXINARF/chocolatey-coreteampackages