text:
# Second-price auction

<Zoe-Version/>

##### [View the code on Github](https://github.com/Agoric/agoric-sdk/blob/958a2c0a3dec38bdba2234934119ea2c28958262/packages/zoe/src/contracts/publicAuction.js) (Last updated: 4/22/2020)
##### [View all contracts on Github](https://github.com/Agoric/agoric-sdk/tree/master/packages/zoe/src/contracts)

In a second-price auction, the winner is the participant with the
highest bid, but the winner only pays the price corresponding to the
second highest bid. Second-price auctions must have sealed (i.e.
private) bids to have the right economic incentives, so this version,
which is entirely public, should not be used in production for real
items.

## Public second-price auction

In this particular "public" second-price auction, anyone who has
access to the auction instance can make a bid by making a proposal.

Alice can create an auction from an existing second-price auction
installation. (`installationHandle` is the unique, unforgeable
identifier for the installation.)

```js
const numBidsAllowed = 3;

const issuerKeywordRecord = harden({
  Asset: moolaIssuer,
  Bid: simoleanIssuer,
});

const terms = harden({ numBidsAllowed });

const aliceInvite = await zoe.makeInstance(
  installationHandle,
  issuerKeywordRecord,
  terms,
);
```

She can put up something at auction by first escrowing it with Zoe. In
order to escrow something with Zoe, she needs to provide a payment for
what she wants to put up at auction, and she needs to make a
`proposal`. The `proposal` will be enforced by Zoe and will protect
Alice from misbehavior by the smart contract and other participants.
`want` and `give` are used to enforce offer safety, and `exit` is used
to enforce payout liveness. If no `exit` rule is given, as in this
example, the default (`{ onDemand: null }`) is used.

```js
const aliceProposal = harden({
  give: { Asset: moola(1) },
  want: { Bid: simoleans(3) },
});

const alicePayments = { Asset: aliceMoolaPayment };

const { outcome: aliceOfferResult, payout: alicePayoutP } = await E(zoe).offer(
  aliceInvite,
  aliceProposal,
  alicePayments,
);
```

Now Alice can spread her invite far and wide and see if
there are any bidders. Let's say that Bob gets the invite and
wants to see if it is the kind of contract that he wants to join. He
can check that the installationHandle installed is the swap he is expecting. He can also check that the item up for sale is the kind that he wants by comparing the issuers.

```js
// Bob collects information about the swap
const inviteIssuer = zoe.getInviteIssuer();
const bobExclusiveInvite = await inviteIssuer.claim(bobInvite);
const bobInviteExtent = inviteIssuer.getAmountOf(bobExclusiveInvite)
  .extent[0];

const {
  installationHandle: bobInstallationId,
  issuerKeywordRecord: bobIssuers,
} = zoe.getInstance(bobInviteExtent.instanceHandle);

// Bob checks the information is what he expects
assert(bobInstallationId === installationHandle, details`wrong installation`);
assert(bobIssuers.Asset === moolaIssuer, details`wrong issuer`);
```

Bob decides to join the contract and
makes an offer:

```js
const bobProposal = harden({
  give: { Bid: simoleans(11) },
  want: { Asset: moola(1) },
});

const bobPayments = { Bid: bobSimoleanPayment };

// Bob escrows with Zoe and bids
const { outcome: bobOfferResult, payout: bobPayoutP } = await E(zoe).offer(
  bobExclusiveInvite,
  bobProposal,
  bobPayments,
);

```

Since multiple parties may want to participate in the auction, let's say that Carol and Dave also decide to bid in the same way
as Bob- Carol bidding 7 simoleans, and Dave bidding 5 simoleans.

Bob wins since he bid 11 simoleans, but pays the second-highest price, which is Carol's bid of 7
simoleans. Thus, when Alice claims her winnings, she gets 7 simoleans.
Bob gets the 1 moola that was up for auction as well as a refund of 4
simoleans (11-7), and Carol and Dave get a full refund.

repository: zramsay/documentation

repo_name: zramsay/documentation


text:
# Bump Version

If you want to bump version (for example, before a release) you should do this in the following places:

- `central-sync/VERSION`
- `maven_coordinates` in `server/src/main/java/org/jetbrains/bsp/bazel/BUILD`
- `VERSION` in `commons/src/main/java/org/jetbrains/bsp/bazel/commons/Constants.java`

repository: JetBrains/bazel-bsp

branch_name: refs/heads/master

extension: md

gha_language: Kotlin

license_type: permissive

repo_name: JetBrains/bazel-bsp


text:
![Ambience Studios Banner](https://github.com/LCordial/ParkourGameTemplate/blob/master/ambience%20studios%20bannertransparentsmall.png)

# 🚧 This Project is in extremly early Stages of Development 🚧
Features may be removed or added in later versions. Use with Care! This Template will be available on the Unity Asset Store, available for everyone without pay!

# Parkour Game Template [V 0.0.1]
A template for a game that is focused on movement and parkour using Unity with simple implementation

This Template has been designed and developed by LCordial that is available for the public.

### This Template Version Includes
   - Main Menu with basic background animation with editable text UI, canvas and background.
   - Advanced player controller including: Wall Running, Sliding, Crouching, Sprinting, Ledge grabbing, Vaulting and Slow Motion.
   - URP Post Processing

# 🖥 Requirements
- Unity Version 2020.1.0f1 or Newer!
- C# Programming Language [Not compatible with JavaScript!]
- Unity URP (CAN BE CHANGED) [Version Requirement coming Soon!]

# 🛠 Getting Started
Install all Requirements needed that are detailed in **Requirements**

##### **Cloning the Repository onto Local**
Using Git or Github Desktop (Doesn't Matter)
Clone this Repository into any local repository using: `https://github.com/LCordial/ParkourGameTemplate.git`.
Once cloned onto local computer, open folder with the required Unity Version. Start Working!
To get working, read this document [here](https://github.com/LCordial/ParkourGameTemplate/blob/master/PROJECTSETUP.md)

##### **Downloading ZIP Folder**
You are able to use this template by downloading as a ZIP folder. By opening this repository, click `Code` and then `Download ZIP`

##### **Downloading using Unity Assest Store**
Not yet available

# 📋 License
MIT License [here](https://github.com/LCordial/ParkourGameTemplate/blob/master/LICENSE.md)

### Report any Bugs/Issues found!
Report any issues encountered with Cloning or setting up. Please report any bugs found during your development! Report bugs here: https://discord.gg/7VUvVsp

###### Thanks to Colanderp!

license: MIT

repository: HXWY/ParkourGameTemplate

gha_license_id: MIT

repo_name: HXWY/ParkourGameTemplate


text:
# Guide To Logging In The Backend Codebase:

## Logging Functions And Variables:

- To log functions and variables, use the two given functions `logFunc()` and `logVar()` in [logging.ts](../../src/logging.ts).
- Please do not use anything else to log functions and variables, as we would like to keep it as consistent as possible across the board with `logFunc()` and `logVar()`.

## Logging Anything Else:

- When logging anything else other than functions and variables (i.e. when you don't need to log a function or variable, but just a message of some sort), use [this](./how_to_add_log.md) guide, which involves importing the logger itself to where you need logging.

## Environmental Variables:

- For local development, in backend/.env, set the environmental variable "MAX_LOG_LEVEL" to the desired value for the max level of log to show. i.e.
  "MAX_LOG_LEVEL=debug" to show all 4 levels
- For Heroku deployment, got to Settings -> Config Vars, and similarly set the MAX_LOG_LEVEL.

## Some Things To Note:

- Only use `error` level when logging a situation that can lead to an error (i.e. something becomes undefined when it's not supposed to).
- For file names, put the actual file name with its corresponding extension. Do not put the file _path_.
- If you don't pass a specific log level to `logFunc()` and `logVar()`, the log level is `info` by default. If you pass a log level that does not match any of the four that we use (`error`, `warn`, `info`, `debug`), it defaults to `info`.
- When logging a function/method using `logFunc()`, put the logging call at the beginning of the function/method body.
- Note that `logFunc()` and `logVar()` contain a lot of optional parameters, so most of the time you don't use all of their parameters and instead you only need 2-3 parameters per `logFunc()` or `logVar()` call.

repository: HKN-UCSD/hkn-server

gha_language: TypeScript

repo_name: HKN-UCSD/hkn-server


text:
# Atomic Reactor Toolkit
<img src="https://preview.ibb.co/kcaAQG/atomic_reactor.png" alt="atomic_reactor" border="0" style="width: 100%; height: auto;" />

A framework for building atomic design systems.

## Quick Start
You can simply clone this repo and run `npm run local` in the cloned directory or install via the Atomic Reactor CLI.

### Install Via Atomic Reactor CLI
1. Globally install the Atomic Reactor CLI:
```sh
$ npm install -g atomic-reactor-cli
```

2. Change directory to the folder where you want to install a new Toolkit:
```sh
$ cd /Development/MyProject
```

3. Run the install command
```sh
$ arcli kit:install
```
> You will be prompted for an optional username and password which can be used to secure the toolkit with [Basic Authentication](https://developer.mozilla.org/en-US/docs/Web/HTTP/Authentication). If you do not wish to secure your butter URL simply press enter/return and skip the prompts.

4. Launch the Toolkit:
```sh
$ npm run local
```

The Toolkit should now be running in your browser and watching for changes to project files. The default url is:
`http://localhost:3000`

> Head over to the [docs](https://github.com/Atomic-Reactor/CLI) for a deeper dive


text:
ofxLua
======

a Lua instance addon

Copyright (c) [Dan Wilcox](danomatika.com) 2011-2012

BSD Simplified License.

For information on usage and redistribution, and for a DISCLAIMER OF ALL
WARRANTIES, see the file, "LICENSE.txt," in this distribution.

See https://github.com/danomatika/ofxLua and the [Openframeworks Forum post](http://forum.openframeworks.cc/index.php?topic=6493.0) for documentation

Description
-----------

ofxLua is an Open Frameworks addon for running a Lua embedded scripting interpreter within an OpenFrameworks application. Using the luabind library, C++ functions and classes can be bound to the lua api allowing them to be called within a lua script. This is useful in separating the upper level logic from the lower level application and is utilized in numerous video games and applications.

In addition, ofxLua provides bindings for the OpenFrameworks API.

[Lua](http://www.lua.org/) combines simple procedural syntax with powerful data description constructs based on associative arrays and extensible semantics. Lua is dynamically typed, runs by interpreting bytecode for a register-based virtual machine, and has automatic memory management with incremental garbage collection, making it ideal for configuration, scripting, and rapid prototyping.

[Luabind](http://www.rasterbar.com/products/luabind.html) is a library that helps you create bindings between C++ and Lua. It has the ability to expose functions and classes, written in C++, to Lua. It will also supply the functionality to define classes in lua and let them derive from other lua classes or C++ classes. Lua classes can override virtual functions from their C++ baseclasses.

[OpenFrameworks](http://www.openframeworks.cc) is a cross platform open source toolkit for creative coding in C++

Build Requirements
------------------

To use ofxLua, first you need to download and install Open Frameworks. ofxPdExample-beta.xcodeproj is developed against the latest version of Open Frameworks on github (007). OF0062 support will be forth coming.

[OF github repository](https://github.com/openframeworks/openFrameworks)

Currently, ofxLua is being developed on Mac OSX. You will need to install Xcode from the Mac Developer Tools.

For Linux, makefiles are included.

The code should work on Windows, but requires Visual Studio and/or Codeblocks project files to be built. Also, you'll need to install Boost and add paths for luabind to find it.

Installation and Build
----------------------

Place ofxLua within a folder in the apps folder of the OF dir tree:

openframeworks/addons/ofxLua

### Which version to use?

If you are using a stable version (0062, 007, ...) of OpenFrameworks then you want to use a git tag of ofxLua for that version. You can select the tag in the Github "Current Branch" menu or clone and check it out using git.

For example, the following commands will clone ofxLua and switch to the OF 0062 tagged version:

git clone git://github.com/danomatika/ofxLua.git
cd ofxLua
git checkout 0062

The master branch of ofxLua will work with the current stable version of OpenFrameworks and can be considered *relatively* stable.

### Dependencies

ofxLua includes the lua and luabind library source files. Luabind requires the [Boost C++ libraries](http://www.boost.org/). Install Boost and include the header and search paths in your project.

### Mac OSX

See the [Homebrew](http://mxcl.github.com/homebrew/) or [Macports](http://www.macports.org) package managers for easy install.

The install command for Homebrew is:

brew install boost

This takes a looong time.

### iOS

A precompiled Boost framework is included in lib/boost as compiling for arm is non-trivial. See [Building Boost for iOS](http://goodliffe.blogspot.com/2010/09/building-boost-framework-for-ios-iphone.html) for more info.

### Linux

Install the boost development library with your distro's package manager.

For example, in Ubuntu you can use apt-get in the terminal:

sudo apt-get install libboost-dev

Running the Example Project
---------------------------

The example projects are in the `example` & `exampleIOS` folders.

### OSX

Open the Xcode project, select the "example-Debug" scheme, and hit "Run".

### Linux

Open the Code::Blocks .cbp and hit F9 to build. Optionally, you can build the example with the Makefile.

To build and run it on the terminal:

make
make run

How to Create a New ofxLua Project
----------------------------------

To develop your own project based on ofxLua, simply copy an example project and rename it. You probably want to put it in your apps folder, for example, after copying:

openFrameworks/addons/ofxLua/example/ => openFrameworks/apps/myApps/example/

It must be 3 levels down in the openframeworks folder structure.

Then after renaming:

openFrameworks/apps/myApps/myLuaProject/

On Mac, rename the project in Xcode (do not rename the .xcodeproj file in Finder!): Long click on the project name in the project tree.

Adding ofxLua to an Existing Project
------------------------------------

If you want to add ofxLua to another project, you need to make sure you include the following src files:

openFrameworks/addons/ofxLua/src/ofxLua.h
openFrameworks/addons/ofxLua/src/ofxLua.cpp
openFrameworks/addons/ofxLua/src/ofxLuaFileWriter.h
openFrameworks/addons/ofxLua/src/ofxLuaFileWriter.cpp

and optionally

openFrameworks/addons/ofxLua/src/ofxLuaWrapper.h

On older Mac OSXs (pre 10.8), a header file which is included with the OS contains some macros which conflict with several lua macros. They can be renamed by setting this CFLAG:

-D__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES=0

This is already set in the static lib Xcode project. See more details [here](http://boost-geometry.203548.n3.nabble.com/problems-with-Boost-Geometry-Xcode-compile-td437866.html).

luabind requires the header search path to the luadbind sources:

../../addons/ofxLua/libs/lua
../../addons/ofxLua/libs/lua/lua
../../addons/ofxLua/libs/luabind

and the header and library search paths to the Boost C++ libraries. See the Project.xconfig of the example project.

### For Xcode:

Include these src files:

openFrameworks/addons/ofxLua/src/ofxLua.h
openFrameworks/addons/ofxLua/src/ofxLua.cpp
openFrameworks/addons/ofxLua/src/ofxLuaWrapper.h

You also need to include the static library Xcode project for the lua and luabind libraries:

# mac os
openFrameworks/addons/ofxLua/lib/luabind.xcodeproj
# or ios
openFrameworks/addons/ofxLua/lib/luabind-ios.xcodeproj

Finally you need to include the header and library search paths required by luadbind. The provided static library xcode project includes the `/usr/local/lib` and `/usr/local/lib` search paths (as used by the Homebrew package manager) to the luabind static lib target. You'll need to change these if Boost is installed to a different dir.

For iOS, you can simply use the included boost.framework in lib/boost/osx. Drag and drop the file form the Finder onto your XCode project tree under addons/ofxLua.

Instructions:

* right click and create a new group "ofxLua"
* drag ofxLua/src into "ofxLua"
* * create a subgroup in ofxLua called "libs"
* drag the `ofxLua/libs/lua` and `ofxLua/libs/luabind` folders into the "ofxLua/libs" subgroup
* drag the `ofxLua/libs/luabind` or `ofxLua/libs/luabind-ios` Xcode project into the "ofxLua/libs" subgroup, make sure the checkbox is checked for your project target in the add dialog box
* under Target->Build Phases, add the static lib project to Target Dependencies and both the lua and luabind libs to Link Binary with Libraries
* under Targets->YourApp->Build->Header Search Paths (make sure All Configurations and All Settings are selected) add:
  * `../../../addons/ofxLua/libs/lua`
  * `../../../addons/ofxLua/libs/lua/lua`
  * `../../../addons/ofxLua/libs/luabind`
  * the path to the Boost headers (for Homebrew, it's `/usr/local/include`)
* under Targets->YourApp->Build->Library Search Paths (make sure All Configurations and All Settings are selected) add the path to the Boost headers

### For Linux (Ubuntu)

Compile the example by running "make".

To use ofxLua in a new project, simply add `ofxLua` to the project's addons.make file.

OF API Bindings
---------------

Luabind bindings for the OF API can be found in `src/bindings`. The implementation is split into separate .cpp files to help keep compilation down to a reasonable degree (as opposed to using all headers).

Currently, it covers *most* of the api and leaves out things involving pointers. More specific documentation may come at a future date, but for now check the example scripts on usage.

To invoke them with ofxLua, simply include ofxLuaBindings.h & call:

    #include "ofxLuaBindings.h"
    ...
    lua.bind<ofxLuaBindings>;

If you don't need the bindings in your project, just remove the `src/bindings` folder from your project files.

Developing
----------

You can help develop ofxLua on GitHub: [https://github.com/danomatika/ofxLua](https://github.com/danomatika/ofxLua)

Create an account, clone or fork the repo, then request a push/merge.

If you find any bugs or suggestions please log them to GitHub as well.

### Trying Newer Lib Versions

There are a number scripts in the scripts folder which are used to update the various libraries (lua, luabind, and boost for iOS) used by ofxLua. Try editing the version setting in the script header and running the script to download new sources or, in the case of boostoniphone, build a new framework.

Bugs / Issues
-------------

### No matching function for call to 'deduce_signature...'

This usually occurs when the trying to bind a function that takes more then 10 arguments. You can change this upper limit using a define when building the luabind lib: LUABIND_MAX_ARITY.

### Reference to 'object' is ambiguous compile error

Luabind has been updated to build with clang (aka LVMM) in Xcode, so this should not be an issue. See this [Github issue](https://github.com/luabind/luabind/issues/4) for details.

With older versions of ofxLua:

If you get a reference to 'object' is ambiguous error at compile time in Xcode, you need to change the compiler from clang to gcc for the luabind static library project. See the Luabind [user forum](http://sourceforge.net/mailarchive/forum.php?thread_name=9D67FA74-F0F7-4AE4-8B2D-C1873A744D51%40fysh.org&forum_name=luabind-user) for more details.

This is set by default in the luabind static library project file.

repository: igoumeninja/ofxLua

repo_name: igoumeninja/ofxLua


text:
## Drop Down Menu

The `DropDownMenu` component is Material-UI's implementation of the
[Textfield dropdown](https://www.google.com/design/spec/components/menus.html#menus-usage).

### Examples


text:
# We-Assert

We-Assert is an assert utility for use in internally verifying statements inside scripts at runtime. One potential goal is to catch what would otherwise be silent errors, or perhaps even
to mathematically prove that an algorithm has functioned as expected.

The tests of this app are the official documentation. Anything documented here in the README might be outdated by accident, but you can run the tests at any time and if the tests pass then they document current usage. Any PR that improves upon the clarity, verbiage, specificity, or exhaustiveness of the tests is welcome.

This project was stale for a long while, but as of June 2023 I have updated it to Version 5, and it is up-to-code. I plan to use it in some of my other projects, so it is likely that I will maintain it better now.

As of version 4, We-Assert has been stripped of Vulcan (https://github.com/RyanMarcus/vulcan), which was packaged with Version 3. The license of We-Assert 4 is the MIT license. What was formerly We-Assert Version 3 is now a new project called We-Assert-Proof, located at https://github.com/xerocross/we-assert-proof. That project is interesting to me, but I find the copyleft license of Vulcan far too restrictive.

## New Stuff

As of V6, the default handler function will now be passed the arguments `(message, assertionLevel, payload)`, which is a breaking change. That is why I have bumped the principal version number. Also, all type checking has been offloaded into a separate project called `@xerocross/data-is`. That package is available publicly.

The function `we.assert.that` is no longer supported as of V6. Use `we.assert.atLevel[assertionLevel].that(...);` instead.

When using the `we.assert.atLevel([level]).that` function, you can now pass
in a function that evaluates boolean to benefit from lazy evaluation, as explained
below. You can also pass in any object as a payload: `we.assert.atLevel("WARN").that("this is true", () => {testThisIsTrue()}, payloadObject`)`.

## Importing

We-Assert is published to NPM as `we-assert`. Standard importing would look like this.
```
import WeAssert from "we-assert"
```

The source code is at https://github.com/xerocross/we-assert.

## Development and Deployment

As of Version 4, we are now using npm to build this project (not yarn, which we used in V2), so to install execute `npm install`.

We-Assert is written in TypeScript.  The package includes a test suite and a script for running it. Use `npm test` to run the test suite, which is written and run using Jest.

## Usage

Below we summarize some of the basic usage. The test suite should be considered the official documentation. Run `npm test` for an exhaustive specification of usage. Any usage not indicated
in the tests may have unexpected results and they are not guaranteed even if documented here in the README.

```
import WeAssert from "we-assert";
var we = WeAssert.build();
```
Here ``we`` is not a singleton.  You can build as many as you want, and each has its own scope and each can be configured independently.

The most basic usage is this: `we.assert.atLevel([assertionLevel]).that(message, statement [, payload])`.  For example
```
we.assert.atLevel("ERROR").that("x < y", x < y);
```
We recommend writing messages that are positive assertions—not an error message to be thrown upon failure.

If the statement evaluates false, the handler will be called.  The handler should be a function of the form `handler : (message, assertionLevel, [,payload]) => {...}`.  To define such a function, we use `we.setHandler` as in this example.
```
we.setHandler((message, level [,payload]) => {
    throw new Error(`The following assertion failed: ${message}`);
});
```
Note how in the handler we have translated the positive assertion into an error message about exactly which assertion failed.  Of course instead of throwing an error you could just swallow it, or log it, or throw the error and log it.  You get the idea.  We-Assert is agnostic to handling the failure of assertions.  Handle it however you want.

We can set the level using any of the following:
`we.setLevel("DEBUG")`, `we.setLevel("WARN")`, or  `we.setLevel("ERROR")`.  The default is "ERROR".

### At Level and Lazy Evaluation

A specific assertion can be assigned a level using the `atLevel` function as in this example.
```
we.assert.atLevel("WARN").that(message, statement);
```

When using atLevel, instead of directly passing a boolean `statement` to be evaluated immediately,
you can pass in a function of the form `() => boolean`, which allows for lazy evaluation.

When using this construction, the *boolean function* will only be evaluated if the level given in the assertion ("WARN") is greater than or equal to the threshhold level defined using `setLevel`.  The order is `DEBUG` < `WARN` < `ERROR`.  Thus, for example, if we set `we.setLevel("ERROR")` and then execute
```
we.assert.atLevel("WARN").that("test", () => statement);
```
then `statement` will not be evaluated and the handler will not be called and nothing will happen because `WARN` is not greater than or equal to the current level `ERROR`.

### handlers and payloads

You can define specific handlers for each level using the methods below.
```
we.setHandler((message, assertionLevel, payload) => {...});
we.setErrorHandler((message, payload) => {...});
we.setWarnHandler((message, payload) => {...});
we.setDebugHandler((message, payload) => {...});
```

For any assertion, you can optionally send a payload along with the message. For example:
`we.assert.atLevel("ERROR").that("x < y", x < y, myObj)`. Here `myObj` is any JavaScript object. You can handle the data in your handler method any way you want.

### Data Validators

In previous versions of We-Assert, data validation functionality was built into We-Assert. As of V6, that functionality has been offloaded into a separate package `@xerocross/data-is`. Here is a usage example.

```
import WeAssert from "we-assert";
import DataIs from "@xerocross/data-is";

const we = WeAssert.build();
const data = DataIs.build();
data.define.type("integer", x => integerTestFunction(x));
we.assert.atLevel("ERROR").that("x is an integer", data(x).is("integer"));
```

repository: xerocross/we-assert

repo_name: xerocross/we-assert


text:
[TOC]

## Problem

When you are creating a background application before your application can consume services, it needs to authenticate.

To authenticate, applications use service principals and OAuth token provided by Azure Active Directory.

## What You Need

Here is what you need:

| Entity         | Description                                                  |
| -------------- | ------------------------------------------------------------ |
| Application Id | Service principal application ID                             |
| Client Secret  | Service principal secret                                     |
| Tenant Id      | Azure Active Directory ID where the service principal is registered |
| Resource Url   | The URL of the resource for which the token is being requested |

## Find Tenant ID

You could find the tenant ID from Azure Portal.

You could also find the Tenant ID using Azure PowerShell:

```powershell
$tenantId = (Get-AzContext).Tenant.Id
```

## Find Application Id and Application Secret

You can take the Application Id from the Overview of the service principal in Azure Active Directory blade in Azure Portal.

You can also create an application secret.

## Request Access Token using REST API

Here is an example how to get access token for the Log Analytics API using PowerShell and HTTP request:

```powershell
$body = @{
    client_id = "<application-id>"
    client_secret = "<application-secret>"
    scope = "https://westus2.api.loganalytics.io/.default"
    grant_type = "client_credentials"
}

$response = (Invoke-RestMethod -Method POST -Uri "https://login.microsoftonline.com/$tenantId/oauth2/v2.0/token" -Body $body)
$token = $response.access_token
```

repository: ZakirQamar/gems

branch_name: refs/heads/main

repo_name: ZakirQamar/gems


text:
# GitDrive

Git friendly backup application for Google Drive.

#### Example

```sh
$ ls
file_mod_1.txt file_mod_2.txt file_new.txt file_ignore.txt
$ gitdrive status
Not staged:
  modified: file_mod_1.txt
  modified: file_mod_2.txt
Not monitored:
  file_add.txt
  file_ignore.txt
$ gitdrive add -u
$ gitdrive add file_add.txt
$ gitdrive status
Staged:
  modified: file_mod_1.txt
  modified: file_mod_2.txt
Not staged:
  new file: file_add.txt
Not monitored:
  file_ignore.txt
$ gitdrive push
Changes:
  2 files updated
  1 new file
```

## Developtment

This project is at an **early development stage**. All codes are in branch `dev`.

repository: mateuspiresl/gitdrive

repo_name: mateuspiresl/gitdrive


text:
---
name: Feature request
about: Suggest an idea for this project - or implement a missing API
title: ''
labels: enhancement
assignees: gjsman

---

**Is your feature request related to a problem or a missing API? Please describe.**
A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]

**Describe the solution you'd like - or the API that needs to be added**
A clear and concise description of what you want to happen.

**Describe alternatives you've considered - or code you've written already**
A clear and concise description of any alternative solutions or features you've considered.

**Additional context**
Add any other context or screenshots about the feature request here.

repository: Homeschool-Connections/ZoomKit

repo_name: Homeschool-Connections/ZoomKit


text:
Blackfire Workshop
==================

This Symfony application is a demo application created to show how you can
profile Symfony applications using [Blackfire.io](https://blackfire.io).

Requirements
------------

- Docker;
- Docker-compose.

**or**

- PHP 7.2 or higher;
- PDO-SQLite PHP extension enabled;
- [Blackfire](https://blackfire.io/getting-started);
- and the [usual Symfony application requirements](http://symfony.com/doc/current/reference/requirements.html).

If unsure about meeting these requirements, download this application and
browse the `http://localhost:8000/check.php` script to get more detailed
information.

Installation (with Docker)
--------------------------

Install dependencies:

```
docker-compose run --rm app composer install
```

Export your Blackfire environment variables:

```
export BLACKFIRE_SERVER_ID=[YOUR-VALUE]
export BLACKFIRE_SERVER_TOKEN=[YOUR-VALUE]
```

And start containers:

```
docker-compose up
```

After this step, jump to section "Usage".

Installation (without Docker)
-----------------------------

Install dependencies:

```
composer install
```

And start server:

```
# With embedded server
app/console server:run --env=prod

# Or with Symfony CLI
symfony serve
```

Usage
-----

You can access the application in your browser at
[http://localhost:8000](http://localhost:8000). You can stop the server by
running `docker-compose down` if you're using docker, or by pressing `Ctrl + C`
while you're in the terminal if you're not using Docker.

> **Note**: if you are using Symfony CLI, you might need to add `/app.php` to
> your URL to get the "prod" environment.

repository: fairhopeweb/blackfire-workshop

repo_name: fairhopeweb/blackfire-workshop


text:
# sfkit
## Street Fighter: The Role-Playing Game Tools

The sfkit is a set of html5 apps for playing the tabletop game with tablets and cell phones and the like. Currently implemented is a character sheet, and a combat card app and a virtual hexmap are also being planned.

Fonts distributed with this package:

 # SSF4_Abuket by ArcJavier
 # DejaVu Sans Latin, Greek & Cyrillic by the DejaVu Fonts Team
 # Komika Jam by Apostrophic Labs

repository: darodrigues/sfkit

repo_name: darodrigues/sfkit


text:
+++
title = "RSoC: Implementing ptrace for Redox OS - part 3"
author = "jD91mZM2"
date = "2019-07-07T08:46:13+02:00"
+++

Table of Contents:

- [Merged!](#merged)
- [Accessing the memory of another process](#accessing-the-memory-of-another-process)
- [Accessing floating point registers](#accessing-floating-point-registers)
- [So... What's next?](#so-what-s-next)

[Pictures of ptrace :)](https://imgur.com/a/rdoOc7q)

# Merged!

Before I dive in to this week's actions, I am pleased to announce that
all the last weeks' work is merged! However, something went
hilariously wrong with [the
squash](https://gitlab.redox-os.org/redox-os/kernel/commit/effe02bd45c2fe4a058b2606cc50d4bbe2c47ff1#note_16912)
and the merge was [re-merged with a new
message](https://gitlab.redox-os.org/redox-os/kernel/commit/788526a3b3586731023c5ee6b0bf5cdaae746828),
but however, with Jeremy as author. Trying to fix one mistake lead to
another, but at least the commit message now makes sense, so I'm not
complaining :)

This merge means you can now experiment with basic ptrace
functionality using only basic registers and
`PTRACE_SYSCALL`/`PTRACE_SINGLESTEP`. I have already opened the second
PR in the batch: [Ptrace memory reading and floating point registers
support](https://gitlab.redox-os.org/redox-os/kernel/merge_requests/104)
which will supply the "final bits" of the *initial* implementation,
before all the nitpicking of final concerns can start (not to
underestimate the importance and difficulty of these nitpicks - there
are some areas of ptrace that aren't even thought about yet and those
will need tending to)! I will comment on these changes in this blog
post, as there are some interesting things going on!

# Accessing the memory of another process

This is perhaps the most interesting change of all. I had to learn
about how processors handle memory: Each process/context has it's own
"page table" which translates parts (here "pages") of "virtual" memory
(in Linux and Redox, 4096 bytes long) to parts (here "frames") of
real, "physical" memory. This means that the pointer `0x12345` on one
process will point to different data than `0x12345` will for another
process. An exception is kernel memory, but only because all processes
map that memory each syscall to a pre-determined address (the virtual
address is still different from the physical one, so it's not much of
an "exception" really).

This paging memory is often portrayed as particularly complicatied -
and it probably is - but luckily I only had to touch the basics.

My first *successful* approach to this was by attaching to the target
process' page table and somehow save the needed memory, perhaps by
using the stack since kernel memory is hopefully mapped in both
processes. That worked, but because the array was on the stack it
could only transfer a limited set of bytes at a time.

![First successful attempt](https://i.imgur.com/nGZvXdn.png)

Then I talked to Jeremy, who told me the kernel would not support swap
memory for a while, so a better way would be to find out the physical
frame of the virtual page containing the requested address, and map it
to the current process as well, translating all addresses. This was
done
[here](https://gitlab.redox-os.org/redox-os/kernel/merge_requests/104/diffs?commit_id=3df1044a53495750e9934daa9b8f39068f3ca011#1408dd4ba159dbf927129c610817b1faf0e08349_209_226).

# Accessing floating point registers

This was really easy for one reason: Jeremy also said the kernel will
*never* touch the floating point registers of a context. So no new
code had to be written to preserve these registers, they are already
saved in the context switch. Since I also made the `syscall`
floating-point struct memory-compatible with the x86\_64 standard,
[the end
product](https://gitlab.redox-os.org/redox-os/kernel/merge_requests/104/diffs?commit_id=be56c246f6de3a2f0fd66c0abb3a0f7f4c8be295#7b7a526df43a73c91157c2f7c350f3a8b92dbe3b_57_60)
was basically just
```rust
unsafe { *(self.fx as *const FloatRegisters) }
```
with a bit of code to discard all the reserved bits to make sure the
user doesn't modify them.

An interesting bit here, though, is that the processor actually uses
80-bit floats. Therefore I got to have some fun to [interpret these in
the strace library](https://gitlab.redox-os.org/redox-os/strace-redox/blob/1579b98dcdacdec3477857bab1c0c9e64a5b117f/src/f80.rs)

# So... What's next?

First, there are a few concerns I have myself which I will need to
attend to in a later PR:

![TODO](https://i.imgur.com/8eAklUD.png)

Help would be welcome over at the
[RFC](https://gitlab.redox-os.org/redox-os/rfcs/merge_requests/14) (be
warned: Redox GitLab does not seem to send notifications!), or any
other way to contact me: Hoping I won't get spammed to bits, I'll
leave my contact details also (I really need help with these
considerations):

- Email: [me<EMAIL_ADDRESS>- Discord: jD91mZM2#1033
- IRC (Freenode/Mozilla): jD91mZM2

I've already gotten some help on the RFC which I am very, very happy
about. People with Linux ptrace experience give a lot of valueable
feedback about the shortcomings of the API and how the Redox API can
be designed better. Even though the basic implementation is done, it's
intentionally programmed so the biggest lowest-level bits are separate
from the main interface, which can therefore be replaced. It's not too
late!

Secondly, I'm working on a compatibility layer for ptrace over at the
[ptrace branch of
relibc](https://gitlab.redox-os.org/redox-os/relibc/tree/ptrace).

repository: redox-os/website

gha_language: CSS

repo_name: redox-os/website


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

[![IMAGE ALT TEXT HERE](https://img.youtube.com/vi/URINAa2NOTQ/0.jpg)](https://www.youtube.com/watch?v=URINAa2NOTQ)

# Motivation

Playing with extracting knowledge from slack data or metadata. For example, try to find similar channels,
based on content.

# Prerequisites

* python3, virtualenv, pip
* a slack api token (API_TOKEN below)
    * see https://api.slack.com/bot-users, specifically https://my.slack.com/services/new/bot

# Install

    virtualenv venv
    source ./venv/bin/activate

    pip3 install -r requirements.txt

# Usage

## Setup defaults

    export API_TOKEN="your-api-token"

## Get base information

Find all messages, for any channels that have between 10 and 1000
recent messages

    python3 crawl.py --token $API_TOKEN

Analyse these messages, extracting what we need for building anything
with them

    python3 analyse.py

## Find similar channels

For a single channel, find top 10 similar channels

    python3 similarity.py --channel some-channel-name --topn 10

## Bulk Convert to channel similarities

Use analysed message content to find similarities between channels, and
convert this similarity to a distance measure, only allowing channels closer
than 0.8.

    python3 similarities.py --distance 0.8 --out content.sims.json

## Visualise channel similarity

Set up vis submodule

    cd vis/
    git submodule init
    git submodule update
    cd ..

Generate visualisation format

    python3 visualise.py --in content.sims.json --out vis/vis.json

Display visualisation (after this step, you rerun generation step and just reload the page)

    cd vis && python3 -m http.server 8000 &
    open http://localhost:8000

## Sharing channel similarity visualisation

If you'd like to share the visualisation, you can just share the contents of the vis/ directory.

If you want to share, but don't want to give away too much about your channel names then try

    python3 visualise.py --in content.sims.json --out vis/vis.json --obfuscate

This will replace parts of channel names with an internally consistent, but arbitrary, replacement
e.g. "my-channel-name" becomes "mazut-duller-toffy" and "my-other-channel-name" becomes
"mazut-tumefy-duller-toffy". The intent of this is to retain any insight from spotting similar-sounding
channel names being related by content, without actually letting anyone know the real names of the channels.

These names are randomized so the exact replacement you see will be
different. By default this will look for random replacement words in /usr/share/dict/words,
but you can point it to any file you like

    python3 visualise.py --in content.sims.json --out vis/vis.json --obfuscate --words-file your-words-file

repository: mikemoraned/tautona

gha_language: Python

repo_name: mikemoraned/tautona


text:
---
title: Who Manages and Spends the Money, and How?
---

The European Commission has the overall responsibility of the implementation of the EU budget, but does not directly manage all EU funds. Indeed, these funds can be spent in several different ways:

-   Through **centralised management**: the money is managed directly by the European Commission (e.g. through the selection of contractors or the award of grants) - this is **centralised direct management** - or indirectly by EU executive agencies, decentralised agencies or national agencies - this is **centralised indirect management**;
-   Through **shared management** (this method accounts for around 80% of the EU budget): there is a delegation of budget implementation to EU Member States;
-   Through **decentralised management**: there is a delegation of budget implementation to non-EU countries;
-   Through **joint management**: there is a delegation of budget implementation to intergovernmental and international organisations.

One fund can be spent in different ways (for example, through centralised and shared management). **For each fund, a specific regulation is adopted which defines the rules related to its implementation.**

****

**Figure 3****. Budget Management Overview**

****

![](../img/image05.png)

Source: [European Commission](http://ec.europa.eu/budget/explained/management/managt_who/who_en.cfm)

Ultimately, a large number of entities are involved in the spending of the EU budget.

-   **The Commission itself and its agencies.**In that case, money will be directly spent through grants, contracts, or administrative expenditures.
-   **National and regional authorities in EU Member States;**
-   **Authorities in non-EU countries** which receive financial support from the EU;
-   **International organisations** such as the United Nations or the World Bank.

As a general rule, the co-financing principle usually applies to EU spending, especially when it comes to shared management. Through this rule, part of the cost of an action or the running costs of an entity is borne by the beneficiary of the grant or by contributors other than the European Commission, with the aim to make beneficiaries responsible for the operational and financial viability of their projects. Some flexibility nevertheless exists to allow for the full financing of some projects with EU funds.

Other rules usually applicable to funding projects with EU money are: the non-profit rule; the non-retroactivity rule and the non-cumulative rule.[^ftnt15]

* * * * *

- [Return to Beginning](../)
- [Prev: Where Does the Money Come From?](../revenue/)
- [Next: Where Does the Money Go?](../funds/)

{% include_relative footnotes.md %}

branch_name: refs/heads/gh-pages

gha_language: HTML


text:
## The Spirit

![](https://raw.githubusercontent.com/edankwan/The-Spirit/master/app/images/screenshot.jpg)

[Live demo](http://www.edankwan.com/experiments/the-spirit/) | [Video](https://www.youtube.com/watch?v=lcHAtTGzQE8)

**The Spirit** is a WebGL experience by Edan Kwan. It uses the noise derivatives and curl noise to create that smoky look and feel. It also uses the **[the new particles](http://www.simppa.fi/blog/the-new-particle/)** which invented by Simo Santavirta [@simppafi](https://twitter.com/simppafi)

This experiment is also inspired by [David Li](http://david.li/)'s [Flow](http://david.li/flow/) experiment.

## Development and deployment
- dev: `node dev`
- deploy: `node build`

## License
This experiment is under MIT License.

gha_language: JavaScript


text:
Below, you will find a brief overview on how to use the custom logging library.

# Editor Window

After installing this package, you will find a new menu item under the `Window` menu: Click `Console XT` to open up the new log window. You can drag-drop it to dock next to the Unity Console window, so you can easily switch between the two later on.

![](MenuItem.png)

Some of the new log window buttons directly mirror functionality from the old Unity Console: `Clear`, `Clear on Play`, `Error Pause` on the left, as well as the message type icons (for messages, warnings and errors) on the right behave exactly like you're used to. In addition to this, you will find the following toolbar items:

* **Redundancy**: When active, redundant parts of adjacent log messages will be "greyed" out to highlight what changed from one line to the next. This is especially useful when there are large numbers of very similar log messages that are only different in a small, but significant part. The redundancy setting helps pinning down those differences more easily.
* **Timestamps**: Toggles whether `Date`, `Time` and `Frame` stamps are displayed next to each log message.
* **Separators**: Toggles whether horizontal separator lines are displayed between log messages that did not occur within the same Unity frame.
* **Trace Details**: Toggles whether selecting a message will display its callstack and source code surroundings.
* **Filter by**: A text field that allows you to filter all displayed messages using a text string or regular expression. Note that the [Mono / .Net flavor of regular expressions](https://www.google.de/search?q=.net+regex+tester) is used.
* **All / System / Default / ...**: There is one button for every log channel that has at least one message in the console. Click on each of them to toggle whether they're displayed.

There are different content areas in the log console, some of which are only visible while a message is selected:

![](EditorWindowAreas.png)

## 1. Main Log Area

* **Click** a message to select it. For messages that have a context object attached to them, this will briefly highlight the context object in the editor.
* **Double-click** a message to jump to the line of source code where the log was written.
* Press **Cmd+C** to copy a message.
* You can also use the **arrow keys** and **Page up / Page down** to navigate.
* As long as you're scrolled to the bottom, the log area will auto-scroll when new messages arrive. This is indicated by a blue bar on the left of the area.

## 2. Message Area

This is where the full message is displayed. Useful for multi-line and very long messages that couldn't be displayed in the main log area.

## 3. Stacktrace

This area provides a stack trace for the selected log message.

* **Click** a stack frame to select it. This will display more context in the source code area.
* **Double-click** a stack frame to jump to the line of source code that is described.
* Stack frames are displayed greyed-out when no matching source file was found for context.
* Stack frames are preceded with an "Unresolved: " prefix when the window was unable to find a matching symbol at all.

## 4. Source Code

This area dislays the source code surroundings for the selected message and stack frame to provide some more context.

# Logging API

Along with the new log console, this package comes with an all new logging API that allows you to use its full functionality. A typical usage will probably look like this:

```cs
// At the top of the file
using ArtCom.Logging;
```
```cs
// Whenever you want to write a log
Logs.Default.Write("Hello World! Foo value: {0}", foo);
```

Let's take a closer look at the last line:

* `Logs` is a static class that provides access to all the log channels, as well as global settings and outputs.
* `Default` is a property that provides access to the default log channel. There is also `System` and `Get<T>` for custom channels.
* `Write` is an instance method on the log channel that writes a regular info message. There are also `WriteWarning`, `WriteError`, `WriteFatal` and `WriteDebug`, each representing a message severity level.
* `Hello World! Foo value: {0}` is the messages format string. Usually, this is a constant value with any number of insertion points for values. It works the same way as Unity's `Debug.LogFormat` and .Net's `string.Format`. For more info on that, take a look at [this docs page](https://msdn.microsoft.com/de-de/library/system.string.format(v=vs.110).aspx), which explains string formatting in detail.
* `foo` is what will be inserted into the logged message at the position of `{0}` inside the string. You can have any number of parameters and reference them by `{index}`.

When logging a more complex operation that spans a larger method call tree, it can sometimes be useful to express scope as part of a log message. One way to do this is by using log indentation:

```cs
Logs.Default.Write("Performing a complex operation...");
Logs.Default.PushIndent();

foo.Bar();
foo.AnotherComplexThing();
foo.Bar2();

Logs.Default.PopIndent();
```

This way, it will become obvious where an operation started and ended, just from looking at the log:

```
[Default] Performing a complex operation...
[Default]   Called foo.Bar
[Default]   Doing foo.AnotherComplexThing...
[Default]     Called nested.Thing
[Default]     Called nested.Thing2
[Default]   Called foo.Bar2
```

When and how log indentation is used is entirely up to you, and it can help in providing a better overview in logfiles and the log console - especially when it's about code that others may not know in-depth.

# Logfile Setup

The custom logging library does not set up a logfile on its own, but it provides a one-liner that you can call in order to do so. When projects use logging, they usually call this right at the beginning of initializing the application. The sometimes used pattern of having a `StartScene` that contains only an `InitApplication` script is a good place for this, but it's up to the user to decide when and how to initialize a logfile.

In the easiest case, this is all you need to do:

```cs
Logs.InitGlobalLogFile();
```

By default, this will ensure a `Logs` directory exists in the local application path, and then create a new logfile named after the current UTC timestamp. If the application path is not writable for some reason (permissions being one of them), it will fall back to using the Unity persistent data path. On Windows machines, this would be the current user's `AppData/LocalLow/CompanyName/ApplicationName`.

When preferred, it is also possible to explicitly set a logfile path and file name pattern in optional method parameters:

```cs
Logs.InitGlobalLogFile("Some\\Logfile\\Directory", "logfile-on-{0:yyyy-MM-dd-HH-mm-ss}.txt");
```

As another optional parameter, it is possible to specify a `TextLogOutputConfig`, describing how log entries will be formatted inside the logfile:

```cs
Logs.InitGlobalLogFile(".", "logfile.txt", new TextLogOutputConfig
{
    WriteFrameStamps = false,
    TimeStampFormat = @"HH\:mm\:ss.fff"
});
```

# Log Formatting

When writing a log entry that involves variables to be inserted, the log needs to convert these values into strings. By default, it will just use .Net's `string.Format` functionality, which will in most cases fall back to each type's `ToString` implementation, but there are some types where it will actually prefer a formatting of its own to help with diagnosing problems.

For example, when you pass a MonoBehaviour of type Foo into a log message, like so:

```cs
Logs.Default.Write("This is a test: '{0}'", foo);
```

What you will see is something like:

```
[Default] This is a test: 'Foo in Full/Path/ToYourObject/InTheHierarchy'
```

As opposed to just the name that you would get in a regular `ToString` call. Likewise, you will get custom string conversions for any of the following types:

* Components
* GameObjects
* Exceptions
* Stackframes
* AppDomains
* Reflection-related types such as `Type` or `MemberInfo`

Should you want to access any of the custom formatting rules outside of a Write call, you will find them in the static `LogFormat` class, which provides various string conversion methods and string format patterns for diagnostic purposes.

## ToString Implementations

On a different note, it can be a very useful practice to provide your own types with a custom `ToString` override for diagnostic purposes. The log implementation will use them just like they are used in any other formatting operation, and it can make the difference between seeing `ArtCom.XY.RectOffset` and `[Left: 10, Right: 10, Top: 20, Bottom: 10]` in the log.

# Log Channels

This package provides multiple log channels and the facilities to define your own. Every log message will carry its channel as a prefix, and the new log console in the editor allows you to toggle filtering by channel, so you'll only see messages from the channels you're interested in. Different log channels can also behave differently - like one of them ending up in the regular logfile, while another one is re-routed to a TCP stream or elsewhere entirely.

From the user perspective, a log channel is any of the following:

```cs
Logs.Default
Logs.System
Logs.Get<SomeCustomChannel>()
```

In terms of the logging library, log channels are `Log` class instances. A `Log` instance is what you're invoking `Write` or indentation methods on, which it will format and error-check before forwarding them to any number of listener instances that are subscribed to it. A typical listener would then take that message and simply write it into a file.

While you could of course just instantiate and configure your own `Log` instance, you'll often want them to be accessible globally and also avoid situations where someone wants to write to a log before it is actually set up. To help you with that, the static `Logs` class acts as a central place to manage and access log channels, specifically using `Logs.Get<T>()` for custom channels.

To define a custom log channel, simply create a new class that derives from `CustomLogInfo` somewhere in your project. This class will serve as a token to represent the log channel: By default, its name will be used to derive the log channels name and prefix, but you can specify each of them explicitly by overriding the `Name` or `Prefix` properties. You can also override the `InitLog` method to do some additional configuration on the log channel when it is first set up. A very simple custom log channel would look like this:

```cs
public class Foo : CustomLogInfo {}
```

Which then could be used globally like this:

```cs
Logs.Get<Foo>().Write("Hello World: {0}", 42);
```

And, by default, resulting in the following log entry:

```
[Foo] Hello World: 42
```

## Trvia: What's up with that syntax?

When thinking about ways to provide a centralized registry for something, a `Dictionary<string,T>` doesn't sound too bad, right? We'd just do a `Logs.Get("Foo")` and would have achieved the same. So what's up with the generic method thing?

The dynamic lookup using a string or a different value has some drawbacks that don't come for free in a logging library. First, you get the overhead of doing a map / dictionary lookup every time you conveniently want to write a log message. It's not a crucial problem, but an annoying one that you'd probably want to do without if you could. Second, any kind of dynamic lookup suffers from the fact that it can fail at runtime. To avoid both of this, the logging library uses the following pattern to access custom log channels:

```cs
public static void Get<T>() where T : CustomLogInfo, new()
{
    return StaticLogHolder<T>.Instance;
}

private static class StaticLogHolder<T> where T : CustomLogInfo, new()
{
    public static Log Instance;

    static StaticLogHolder() {
        // Simplified:
        Instance = new Log();
    }
}
```

The above means that, for every log channel you define, there will be an internal generic class with a static field storing it, which solves both of our problems: Performance will be a non-issue, as there is no lookup. When you write `Logs.Get<T>`, the compiler already knows exactly where it will look for the instance you're retrieving, and it might even optimize away the `Get` call as a bonus.

For the above to be true, we could use any class as a generic argument to identify a log channel. However, by enforcing that we only do this with classes that derive from `CustomLogInfo`, we can use this class to store additional parameters and provide config methods as were mentioned in the section before.

# Log Listeners

A log channel / `Log` instance accepts log messages you put into it, but it won't do anything useful with them. It acts as an endpoint to write messages to, but how they will be handled is up to the log listeners that are subscribed to it.

Every log channel has its own set of listeners, which you can adjust using `AddOutput` / `RemoveOutput` API. It is also possible to add a listener globally to all channels using the static `Logs.AddGlobalOutput` / `Logs.RemoveGlobalOutput` API, which is what happens when the default logfile is initialized. The most common listener type is the `TextWriterLogOutput`, which will transform every log entry into text, and write that text using a .Net `TextWriter` to its underlying `Stream`.

You can define your own listeners by implementing the `ILogOutput` interface in a class, and then adding instances of it to the global or a channels individual output list. Example:

```cs
    public class CustomLogOutput : ILogOutput
    {
        private int indentLevel = 0;

        public virtual void Write(Log source, LogEntry entry, object context)
        {
            // 'source' is the channel where the message was logged.
            //
            // 'context' is an object associated to that message, usually
            // derived from formatting parameters and often a MonoBehaviour
            // or GameObject that was mentioned. It's the object that is
            // highlighted when clicking the message in the editor window.
            //
            // 'entry.Type' specifies message severity (Info, Warning, Error, ...)
            // 'entry.Message' is the string to be logged.
            // 'entry.TimeStampTicks' is the messages UTC tick count.
            // 'entry.FrameStamp' is the Unity frame number when the message was written.

            // Now go and do something interesting!
        }
        public void PushIndent()
        {
            indentLevel++;
        }
        public void PopIndent()
        {
            indentLevel--;
        }
    }
```

```cs
// You would usually do this next to the line where you
// initialize the global logfile as well.
Logs.AddGlobalOutput(new CustomLogOutput());
```

repository: belzecue/ConsoleXT

repo_name: belzecue/ConsoleXT


text:
---
title: '李伟慧'
permalink: /test/李伟慧/
breadcrumb: '李伟慧'
---

Back

*Video is best viewed in 1080p.

Lee Wei Hui

    李伟慧

介绍

李伟慧老师是教育部课程规划与发展司的高级专科督导，从事教育工作十五年，是“2015年小学华文课程”的规划与编写团队成员之一。目前，她除了参与小学华文课程的咨询与相关研究工作，也参与小学教师的培训工作。

 简介

快乐识字，享受阅读
阅读是孩子认识世界的开端，阅读能力是重要的学习能力之一，而识字是阅读的基础。如果能用正确、有趣的方法帮助孩子识字，就能使孩子尽早开始自主阅读，从而促进阅读能力和相关智力的发展。教育部课程专科督导将分享小学华文课程《欢乐伙伴》是如何帮助低年级孩子识字，并培养他们的阅读能力的。家长从中可学到有趣的方法，获得更多点子，帮助孩子巩固识字，协助他们进入自主阅读的世界。

Profile

Mdm Lee Wei Hui is a Senior Specialist at the Curriculum Planning and Development Division at MOE HQ with 15 years of experience in the Education Service. She was part of the team that planned and developed the 2015 Primary Chinese Language Curriculum and is now involved in consultation and research for the Primary Chinese Language Curriculum, and training of primary school Chinese Language teachers.

Synopsis

 Fun with Word Recognition, Joy with Reading

Reading is an avenue for children to know the world and is an essential learning competence. Character recognition is the foundation to developing reading skills. With appropriate and interesting approaches to learn recognition of Chinese characters, children will be able to read independently in their early years. This will, in turn, improve their reading and other academic skills. The speaker will provide insights on how children at the lower primary level are learning to recognise characters and read independently in class using the 2015 Primary Chinese Language Curriculum. Parents will be able to learn interesting ideas to help their children reinforce learning and assist them to read independently.

Top

repository: isomerpages/moe-mtls

branch_name: refs/heads/staging

gha_language: SCSS

gha_license_id: NOASSERTION

repo_name: isomerpages/moe-mtls


text:
MinifyHtml
==========

CakePHP 4, HTML Minify Plugin

### Installation ###

To install via [Composer](http://getcomposer.org/), use the command below, it will automatically detect the latest version and bind it with `~`.

```
composer require wyrihaximus/minify-html
```

## Bootstrap ##

Plugins are loaded in your application’s `bootstrap()` function:

```php
// In src/Application.php
use Cake\Http\BaseApplication;
use WyriHaximus\MinifyHtml\Plugin as MinifyHtmlPlugin;

class Application extends BaseApplication {
    public function bootstrap()
    {
        parent::bootstrap();

        // Load the minify html plugin by class name
        $this->addPlugin(MinifyHtmlPlugin::class);
    }
}
```

### Usage ###

After loading this plugin in your `bootstrap.php` the helper can be enabled in the `AppView` by loading the `WyriHaximus/MinifyHtml.MinifyHtml` helper like the example below:

```php
class AppView extends View
{
    public function initialize(): void
    {
        $this->loadHelper('WyriHaximus/MinifyHtml.MinifyHtml');
    }
}
```

#### Note on debug ####

When debug mode is on nothing will be minified.

### Usage in other plugins ###

##### [dereuromark/cakephp-cache](https://github.com/dereuromark/cakephp-cache) #####

To use MinifyHtml instead of `dereuromark/cakephp-cache`'s own HTML minifier. Set the [`compress` configuration option](https://github.com/dereuromark/cakephp-cache#component-configuration) to:
```php
'\WyriHaximus\MinifyHtml\compress'
```

### Configuration ###

All configuration is namespaced, just as this plugin into `WyriHaximus.MinifyHtml`. The following options are available:

`debugOverride` (bool) Defaults to `false`. Everwrite debug and minify when debug it on.
`factory` (string) Defaults to `WyriHaximus\HtmlCompress\Factory::constructFastest`. Speficy a parser factory, `constructFastest`, `construct`, and `constructSmallest` are build in.

### License ###

Copyright 2019 [Cees-Jan Kiewiet](http://wyrihaximus.net/)

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

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

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

repository: WyriHaximus/MinifyHtml

gha_language: PHP

repo_name: WyriHaximus/MinifyHtml


text:
### Preparation of Vagrant box

Create and enter a new parent directory for your Vagrant box:

    mkdir ralph_vagrant
    cd ralph_vagrant

Create Vagrant file in the parent directory:

    cat -> Vagrantfile
    Vagrant.configure("2") do |config|
      config.vm.box = "ubuntu/bionic64"
      config.vm.hostname = "ralph"
      config.vm.network "forwarded_port", guest: 80, host: 8000
      config.vm.provider "virtualbox" do |vb|
        vb.memory = "2048"
      end
    end
    ^D

Start and enter the box:

    vagrant up
    vagrant ssh

branch_name: refs/heads/ng


text:
### [CVE-2019-10800](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-10800)
![](https://img.shields.io/static/v1?label=Product&message=codecov&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=%3C%202.0.16%20&color=brighgreen)
![](https://img.shields.io/static/v1?label=Vulnerability&message=Command%20Injection&color=brighgreen)

### Description

This affects the package codecov before 2.0.16. The vulnerability occurs due to not sanitizing gcov arguments before being being provided to the popen method.

### POC

#### Reference
- https://snyk.io/vuln/SNYK-PYTHON-CODECOV-552149

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

repository: trickest/cve

repo_name: trickest/cve


text:
# Stack-based Github workflow
We believe that small pull requests contribute to better code quality, because
both the author and reviewer can focus on a single aspect.

However, breaking up your work into small pieces, especially if you are working
on multiple issues at the same time, quickly turns into a nightmare of branches,
merges and chores. That is, if you manage a single branch per pull request.

This tool instead supports a work flow that uses only a single local working
branch, managing a single stack of commits, one per pull request.

We are constantly rebasing the stack on top of master, and we are doing more
rebasing to move hunks between commits and change the order of commits. In fact,
we are editing our code while being in an ongoing rebase.

# Workflow
First of all, let's make sure we are in sync with the latest master

    $ git review sync

Assume you want to add foo to bar next. Run

    $ git review new -j PROJ-1234 -m "Add foo to bar"

This will create a new commit for you for that specific task, tracked by the
provided Jira ticket. Now run

    $ git review rebase

and an editor opens. Put the new commit into its correct place of the stack, and
mark it with "edit".  Then run

    $ git review export

which will update all remote tracking branches for all commits in your stack
that are not marked with "wip", and creates a pull-request for those for which
there is none yet. See yourself with

    $ git review log -p

Follow the HTTP links to the pull requests to assign a reviewer or read the
comments.

Address your reviewer's comment by doing another

    $ git review rebase
    $ # do the work
    $ git add -A .
    $ git rebase --continue
    $ git review export

As soon as the reviewer and continuous integration are okay with your PR, merge
it through Github and delete the remote branch. Then sync with master (as
described above) and check with `git review log` that the commit is gone from
your stack.

# Caveats, known issues

1. If your reviewer has pushed a commit on the remote tracking branch, the next
`git review export` will overwrite it!

1. All pull requests go against master, so each commit that is not at the bottom
of your stack will have a pull request with all the commit below of it. Ask your
reviewer to only review that single commit, and hope they are fine with that.

# Getting started
## Installation
Create a sym-link called `git-review` that points at `git_review.py` and add it
to your PATH. Then git will find it when you run `git review`.

## Configuration

Pick a name for your working branch, let's say "stack" and run

    $ git config --local --add review.branch stack

Then, for Github integration, go to https://github.com/settings/tokens,
generate a new API token, give the token "repo" rights, and then run

    $ git config --local --add review.api-token api-token

Finally, run

    $ git config --local --add review.user github-user

repository: copton/git-review

repo_name: copton/git-review


text:
---
title:  Tomcat Hates Encoded Slashes
author: Ray Nicholus
categories: Tomcat server HTTP REST Java JavaScript
excerpt: "After sending a GET request containing escaped slashes to our Tomcat-hosted endpoint, we expect to receive a 2xx response. But instead, our server responds with a 404. What happened?"
---

Let's picture a small segment of a typical web application in order to better understand this problem. We'll focus mostly on the server here, but the client plays a key role as well. On the server, we have a REST endpoint that exists to proxy information from _another_ endpoint. This handler accepts GET requests. The _other_ endpoint to proxy is included as a path parameter. The signature of our endpoint handler looks something like this:

```java
@GET
@Path("proxy/{url}")
String getData(@PathParam("url") String url);
```

In case it is not already obvious, the above code is part of a Java interface, and the annotations are part of the [javax.ws.rs package][javaxws], which is a collection of interfaces and annotations that align with the [JSR 311 specification][jsr311] maintained by the [Java Community Process group][jcp].

The exact implementation of the above endpoint method is unimportant, so I'll omit it for the sake of brevity. When called, it will simply make a GET request to the address specified at the end of the `@Path`, which is stored in the `url` parameter. The response from the resource associated with this `url` will return some data in the response, and this data will then be returned to whichever client called our "proxy/" endpoint. Our client code may very well be running in a browser, in which case it may look something like this:

```javascript
var resourceToProxy =
  encodeURIComponent('http://widen.com/careers')

fetch('/proxy/' + resourceToProxy)
  .then(function(response) {
    if (response.ok) {
      return response.text()
    }
    else {
      var error = new Error(response.statusText)
      error.response = response
      throw error
    }
  })
  .then(function(proxiedData) {
    // handle proxied data in response
  })
  .catch(function(err) {
    console.error(error)
  })
```

The above client-side code utilizes the native [Fetch API][fetch], but you could accomplish the same call with [`XMLHttpRequest`][xhr]. In fact, the client doesn't even need to be browser-based - it could very well live on a server, coded in any language under the sun.

## The problem

After executing the above request, we would fully expect to receive a 2xx response from our server and then handle the proxied data via the success function of fetch's returned promise. But instead, our error handler is invoked. Looking closer, we see that our server returned a response code of [404][404]. But we've clearly defined our endpoint, and even verified that our request is being properly set to this endpoint. So what happened?

## The cause

I left out one _minor_ detail - our web server is [Apache Tomcat][tomcat], which is very common when Java is the primary server language. In version 6.0.10 (released around February of 2007), [the Tomcat team patched a security hole][tomcat-security]. This involved treating encoded forward and backslashes in the URL as path delimiters. So, our URI of "/proxy/http%3A%2F%2Fwiden.com%2Fcareers" is being expanded to "/proxy/http%3A//widen.com/careers" _before_ it is routed to a matching endpoint handler. Of course, this endpoint is not accounted for, and our server rejects the request as a result.

## The solution

There are two ways to work around this behavior. The first involves adjusting a Java system property on our application server. Setting the `org.apache.tomcat.util.buf.UDecoder.ALLOW_ENCODED_SLASH` system property to `true` should allow our request to go through as expected. The default value of this property is `false`. Another option involves switching our GET request to a POST and including the url to proxy in the message-body. This is arguably the safest option. If we take this route, our server endpoint will look like this:

```java
@POST
@Path("proxy/url")
String getData(String url);
```

The body of our POST request will be made available to our handler method via the `url` parameter. We will have to make a slight adjustment to our client-side code as well:

```javascript
var resourceToProxy = 'http://widen.com/careers'
fetch('/proxy/url', {method: 'POST', body: resourceToProxy})
  .then(function(response) {
    if (response.ok) {
      return response.text()
    }
    else {
      var error = new Error(response.statusText)
      error.response = response
      throw error
    }
  })
  .then(function(proxiedData) {
    // handle proxied data in response
  })
  .catch(function(err) {
    console.error(error)
  })
```

Note that there is no need to encode the proxy endpoint address anymore, since it is no longer part of the request URI. The changes to our JavaScript are limited to the first two lines of code. This will result in A POST request to our "/proxy/url" endpoint with a Content-Type of "text/plain". As expected, the body of our request will contain the `resourceToProxy` value. After making these changes, everything works as intended, and we are able to successfully proxy a third-party endpoint through our server.

[404]: http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4.5
[fetch]: http://davidwalsh.name/fetch
[javaxws]: https://docs.oracle.com/javaee/7/api/javax/ws/rs/package-summary.html
[jcp]: https://www.jcp.org/en/home/index
[jsr311]: https://jcp.org/en/jsr/detail?id=311
[tomcat]: http://tomcat.apache.org/
[tomcat-security]: http://tomcat.apache.org/security-6.html#Fixed_in_Apache_Tomcat_6.0.10
[xhr]: https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest

branch_name: HEAD


text:
###This is a Chinese version of Lobsters.

See the original git source: [https://github.com/jcs/lobsters](https://github.com/jcs/lobsters),

And the living demo: [https://lobste.rs](https://lobste.rs).

####Installation

* Install Ruby 1.9.3 or higher.

* Checkout the lobsters git tree from Github

         $ git clone git@github.com:krongk/lobsters-cn.git
         $ cd lobsters-cn
         lobsters-cn$

* Run Bundler to install/bundle gems needed by the project:

         lobsters-cn$ bundle

* Update folder `file_to_copy`, and copy or overwrite to each directories:

          config/database.yml
          config/application.yml
          config/initializers/secret_token.rb
          config/initializers/domain.rb
          db/seeds.rb

* Load the schema into the new database:

          lobsters-cn$ rake db:create
          lobsters-cn$ rake db:schema:load
          lobsters-cn$ rake db:seed

* (Optional, only needed for the search engine) Install Sphinx.  Build Sphinx
config and start server:

          lobsters-cn$ rake thinking_sphinx:rebuild

* Run the Rails server:

          lobsters-cn$ rails server

repository: krongk/lobsters-cn

repo_name: krongk/lobsters-cn


text:
# Genome Payment Android SDK

[![GitHub release](https://img.shields.io/github/v/release/genome-eu/payment-sdk-android?style=flat-square&cacheSeconds=60)](https://github.com/genome-eu/payment-sdk-android/releases)
[![License](https://img.shields.io/github/license/genome-eu/payment-sdk-android?style=flat-square)](https://github.com/genome-eu/payment-sdk-android/blob/master/LICENSE)

The Genome Payment Android SDK makes it quick and easy to build a payment screen in your Android app. We provide customizable SDKFacade that can be used out-of-the-box.

## Content
* [Requirements](#requirements)
* [Installation](#installation)
* [Integration with SDK](#integration-with-sdk)

## Requirements
Android 5.0 (API level 21) and above

## Installation
To integrate the Genome Payment Android SDK, you need to perform a few basic tasks to prepare your Android Studio project:

### 1. Edit your project Gradle file
Add rules to your root-level build.gradle file:
```
allprojects {
    // ...
    repositories {
        // ...
        mavenCentral()
    }
}
```

### 2. Edit your module Gradle file
In your module Gradle file (usually the app/build.gradle), add the implementation(...) line in your dependencies to import the SDK:
```
apply plugin: 'com.android.application'

android {
  // ...
}

dependencies {
  // ...
  implementation 'eu.genome.android:sdk-payment:1.1.0'
}
```

## Integration with SDK

[How integrate SDK to your project see here](readme/INTEGRATION.md).

repository: genome-eu/payment-sdk-android

repo_name: genome-eu/payment-sdk-android


text:
---
title: GUI
---

Kuma now ships with a basic web-based GUI that will serve as a visual overview of your dataplanes, meshes, and various traffic policies.

{% tip %}
The GUI pairs with the HTTP API — Read more about the HTTP API [here](/docs/{{ page.version }}/reference/http-api)
{% endtip %}

When launching Kuma, the GUI will start by default on the API port, and defaults to `:5681/gui`. You can access it in your web browser by going to `http://localhost:5681/gui`.

## Getting Started
When you run the GUI for the first time, you’ll be presented with the Wizard:

### This tool will:
1. Confirm that Kuma is running
2. Determine if your environment is either Universal or Kubernetes
3. Provide instructions on how to add dataplanes (if none have yet been added). The instructions provided will be based on your Kuma environment -- Universal or Kubernetes
4. Provide a short list of dataplanes found and their status (online or offline), in order to confirm that things are working accordingly and the app can display information

## Mesh Overview
Once you’ve completed the setup process, you’ll be sent to the Mesh Overview. This is a general overview of all of the meshes found. You can then view each entity and see how many dataplanes and traffic permissions, routes, and logs are associated with that mesh.

## Mesh Details
If you want to view information regarding a specific mesh, you can select the desired mesh from the pulldown at the top of the sidebar. You can then click on any of the overviews in the sidebar to view the entities and policies associated with that mesh.

{% tip %}
If you haven't yet created any meshes, this will default to the `default` mesh.
{% endtip %}

Each of these views will provide you with a table that displays helpful at-a-glance information. The Dataplanes table will display helpful information, including whether a dataplane is online, when it was last connected, how many connections it has, etc. This view also provides a control for refreshing your data on the fly without having to do a full page reload each time you've made changes:

We also provide an easy way to view your entity in YAML format, as well as a control to copy it to your clipboard:

The dataplane view will enable you to see all policies that affect a specific dataplane:

It also gives you access to the full Envoy configuration of each dataplane which is useful when troubleshooting:

## What’s to come
The GUI will eventually serve as a hub to view various metrics, such as latency and number of requests (total and per entity). We will also have charts and other visual tools for measuring and monitoring performance.


text:
# RSVP

RSVP website for wedding.

## Getting Started

These instructions will get you a copy of the project up and running on your local machine for development and testing purposes. See deployment for notes on how to deploy the project on a live system.

### Prerequisites

To start working you will need to install the following:
* [NodeJs](https://nodejs.org/en/)
* [npm](https://www.npmjs.com/) (Usually installed with NodeJs)
* [MongoDb](https://www.mongodb.com/).

### Installing

First clone repository and start the mongo database.

#### Server

1. Go to server directory `cd server`
2. Install dependencies `npm i`
3. Update config
4. Run the server `npm start`

You can now acces the server on http://localhost:8083.

#### Client

1. Go to client directory `cd client`
2. Install dependencies `npm i`
3. Update enviroment variables (.env file)
4. Start dev server for client `npm start`

You can now acces the client on http://localhost:8080/rsvp.

## Deployment

Start by updating the configs for the production enviroment.

For the deployment you should go inside the client folder and then run `npm run build`. This will create a production build from the client under the folder `client/dist`. This folder can then be served to the client using the server by moving these files to the `server/client` folder.

Then in your production setup you only need to run the server to go live.

## Built With

* [NodeJs](https://nodejs.org/en/)

* [Vue](https://vuejs.org/)
* [buefy](https://buefy.org/)
* [axios](https://github.com/axios/axios)

* [express](https://expressjs.com/)
* [mongodb](https://www.mongodb.com/)
* [Node-config](https://lorenwest.github.io/node-config/)
* [svg-to-pdfkit](https://github.com/alafr/SVG-to-PDFKit)

## Versioning

We use [SemVer](http://semver.org/) for versioning. For the versions available, see the [tags on this repository](https://github.com/your/project/tags).

## License

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

repository: depuits/rsvp

gha_language: Vue

repo_name: depuits/rsvp


text:
# EbbsianThemeforObsidian
A minimal light theme with rainbow coloured accents.

# Thanks
Many thanks to Deathau for their [Notation Theme](https://github.com/deathau/Notation-for-Obsidian), on which the headers and tables were based.

# To make things work
Download the css file and drop it into your themes folder!

## Fonts
The fonts used should work automagically, but if they don't (or you want to work offine, as they currently pull directly from Google fonts), the primary fonts used are:
- Headers: [Raleway](https://fonts.google.com/specimen/Raleway)
- Body: [Spectral](https://fonts.google.com/specimen/Spectral)

FontAwesome is used for the callout boxes.
[Download here](https://fontawesome.com/how-to-use/on-the-desktop/setup/getting-started) and install the solid bold otf.

## Settings
This theme is compatible with the Style Settings plugin - there are options to change the header image, accent colour, and header underline colours, as well as the body and header fonts.

# Screenshots

# Callout Boxes

The theme comes with some built-in callouts in various colours / flavours.
You'll need FontAwesome installed to make these work!

## Quote Callout Boxes
### Summary
This box is the quickest and easiest to use - simply put your text inside two quotes.
```
>> Lorem ipsum
```

### Warning
Three quotes gives you a red warning box.

```
>>> Lorem ipsum
```

## Solid Colour Boxes
These are generated using code blocks with the header note-s-$.

### Solid Red Warning
A red box with a warning symbol.

```
``` note-s-warning
Example text.
```

<img src="./Screenshots/Boxes%20and%20Callouts/note-s-warning.PNG" width="70%">

### Orange Highlight
Orange box with a highlight symbol.
```
``` note-s-highlight
Example text.
```

### Yellow Bookmark
Yellow box with bookmark symbol.

```
``` note-s-bookmark
Example text.
```

<img src="./Screenshots/Boxes%20and%20Callouts/note-s-bookmark.PNG" width="70%">

### Green Write
Green box with a quill pen symbol.
```
``` note-s-write
Example text.
```

### Blue Folder
Blue box with a folder symbol.
```
``` note-s-folder
Example text.
```

<img src="./Screenshots/Boxes%20and%20Callouts/note-s-folder.PNG" width="70%">

### Purple Clipboard
Purple box with a clipboard symbol.

```
``` note-s-clip
Example text.
```

## Plain Outlined Boxes
White boxes with coloured outlines and no symbols.
These use code blocks with the syntax note-{colour}.
### Red
```
``` note-red
Example text.
```
<img src="./Screenshots/Boxes%20and%20Callouts/note-red.PNG" width="70%">

### Orange
```
``` note-orange
Example text.
```

### Yellow
```
``` note-yellow
Example text.
```

<img src="./Screenshots/Boxes%20and%20Callouts/note-yellow.PNG" width="70%">

### Green
```
``` note-green
Example text.
```

### Blue
```
``` note-blue
Example text.
```

<img src="./Screenshots/Boxes%20and%20Callouts/note-blue.PNG" width="70%">

### Purple
```
``` note-purple
Example text.
```

### Pink

```
``` note-pink
Example text.
```

license: Unlicense

repository: ebbsian/EbbsianThemeforObsidian

gha_license_id: Unlicense

repo_name: ebbsian/EbbsianThemeforObsidian


text:
# Scala.js typings for macos-release

Typings are for version 3.1.0

## Library description:
Get the name and version of a macOS release from the Darwin version

|                    |                 |
| ------------------ | :-------------: |
| Full name          | macos-release |
| Keywords           | macos, os, darwin, operating, system, platform, name, title, release, version |
| # releases         | 7 |
| # dependents       | 0.0 |
| # downloads        | 1.2866205E7 |
| # stars            | 44.0 |

## Links
- [Homepage](https://github.com/sindresorhus/macos-release#readme)
- [Bugs](https://github.com/sindresorhus/macos-release/issues)
- [Repository](https://github.com/sindresorhus/macos-release)
- [Npm](https://www.npmjs.com/package/macos-release)

## Note
This library has been generated from typescript code from first party type definitions.

Provided with :purple_heart: from [ScalablyTyped](https://github.com/oyvindberg/ScalablyTyped)

## Usage
See [the main readme](../../readme.md) for instructions.

repository: ScalablyTyped/Distribution

repo_name: ScalablyTyped/Distribution


text:
---
title: Flood Cup, Round 6 results
date: 2018-05-15
authors: tmorris
---

### Results

###### 20180511

| WHITE           | BLACK           | Notes       |
| --------------- | --------------- | ----------- |
| Brian Willcock  | Tony Howes      | 0-1         |
| Tony Morris     | Mark Pendrith   | *postponed* |
| Rex Scarf       | Martin Laizans  | *postponed* |
| Andrew Robinson | Chesley Cutler  | ½-½         |

----

### Games

##### Andrew Robinson v Chesley Cutler

<iframe src="https://lichess.org/embed/FU4nhGsD?theme=auto&bg=auto" width=600 height=397 frameborder=0></iframe>

----

### Current standings

| Rank | Name            | Points | Played |
| :--: | --------------- | :----: | :----: |
| 1    | Rex Scarf       | 4½     | 5      |
|      |                 |        |        |
| 2    | Tony Howes      | 5      | 7      |
|      |                 |        |        |
| 3    | Tony Morris     | 3½     | 6      |
|      |                 |        |        |
| 4    | Andrew Robinson | 3      | 5      |
|      |                 |        |        |
| 5    | Brian Willcock  | 3½     | 5      |
|      |                 |        |        |
| 6    | Mark Pendrith   | 1½     | 4      |
|      |                 |        |        |
| 7    | Martin Laizans  | 1      | 5      |
|      |                 |        |        |
| 8    | Chesley Cutler  | 1      | 7      |
|      |                 |        |        |


text:
Pickle
======

Pickle uses the Scala Simple Build Tool (SBT) for building and running.

To build:

sbt compile

To run:

start sbt
$sbt

run an application

Pickle Simulation
>pickle apps/SheepFlocking.xml

repository: hnnguyen/SheepSimulatorPickle

repo_name: hnnguyen/SheepSimulatorPickle


text:
# Building and installing neml

For detailed instructions see the [readthedocs](https://neml.readthedocs.io/en/latest/started.html) documentation.

If you are building only the base library you can build in or out of the source
directory.
For the python bindings we recommend building in-source.
These instructions assuming you are building in the source directory.

## Linux (Ubuntu/APT)

To compile just the base library:

```
apt-get install build-essential cmake libblas-dev liblapack-dev
cmake .
make
```

To compile both the base library and the python bindings:

```
apt-get install build-essential cmake libblas-dev liblapack-dev python-dev python-networkx python-numpy python-scipy python-matplotlib python-nose
cmake -D WRAP_PYTHON=ON .
make
```

and run the tests with

```
nosetests
```

## macOS (homebrew)

For just the base library setup prerequisites

```
brew install boost cmake
```

and then build the library

```
cmake .
make
```

For the library and the python bindings setup prerequisites

```
brew install boost cmake python@2
pip install nose numpy scipy nose matplotlib networkx
```

and then build the library
```
cmake -D WRAP_PYTHON=ON .
make
```

repository: Argonne-National-Laboratory/neml

branch_name: refs/heads/dev

repo_name: Argonne-National-Laboratory/neml


text:
---
title: Filtering Row
page_title: Filtering Row - WinForms GridView Control
description: Get familiar with the properties that control the filtering row appearance in WinForms GridView.
slug: winforms/gridview/filtering/filtering-row
tags: filtering,row
published: True
position: 1
previous_url: gridview-filtering-filtering-row
---

# Filtering Row

The __GridFilterRowElement__ is the row that holds the filtering boxes. It appears automatically when you enable filtering (__EnableFiltering__ is __true__). __GridFilterRowElement__ could be pinned at the top or bottom as well as made scrollable.

![WinForms RadGridView Filtering Row](images/gridview-filtering-filtering-row001.png)

You can hide the operator text of the filter cells by setting the __ShowFilterCellOperator__ property to *false*:

## Hide Operator Text

{{source=..\SamplesCS\GridView\Filtering\Filtering.cs region=filterOperatorText}}
{{source=..\SamplesVB\GridView\Filtering\Filtering.vb region=filterOperatorText}}

````C#
this.radGridView1.MasterTemplate.ShowFilterCellOperatorText = false;

````
````VB.NET
Me.RadGridView1.MasterTemplate.ShowFilterCellOperatorText = False

````

{{endregion}}

![WinForms RadGridView gridview-filtering-filtering-row 002](images/gridview-filtering-filtering-row002.png)

You can also hide the entire __GridFilterRowElement__:

## Hide filter row

{{source=..\SamplesCS\GridView\Filtering\Filtering.cs region=hidingTheFilterRow}}
{{source=..\SamplesVB\GridView\Filtering\Filtering.vb region=hidingTheFilterRow}}

````C#
this.radGridView1.ShowFilteringRow = false;

````
````VB.NET
Me.RadGridView1.ShowFilteringRow = False

````

{{endregion}}

You can still add [FilterDescriptors]({%slug winforms/gridview/filtering/setting-filters-programmatically-(simple-descriptors)%}) programmatically when the __GridFilterRowElement__ is hidden.

## Filter Menu

The menu with the filter operators is actually a context menu. So if you want to modify it you need to use the __ContextMenuOpening__ event. Detailed information is available here: [Modifying the Default Context Menu]({%slug winforms/gridview/context-menus/modifying-the-default-context-menu%})

## See Also

* [Basic Filtering]({%slug winforms/gridview/filtering/basic-filtering%})

* [Customizing composite filter dialog]({%slug winforms/gridview/filtering/composite-filter-dialog%})

* [Custom Filtering]({%slug winforms/gridview/filtering/custom-filtering%})

* [Events]({%slug winforms/gridview/filtering/events%})

* [Excel-like filtering]({%slug winforms/gridview/filtering/excel-like-filtering%})

* [FilterExpressionChanged Event]({%slug winforms/gridview/filtering/filterexpressionchanged-event%})

* [Put a filter cell into edit mode programmatically]({%slug winforms/gridview/filtering/put-a-filter-cell-into-edit-mode-programmatically%})

* [Setting Filters Programmatically (composite descriptors)]({%slug winforms/gridview/filtering/setting-filters-programmatically-(composite-descriptors)%})

repository: telerik/winforms-docs

repo_name: telerik/winforms-docs


text:
# **Finding Lane Lines on the Road**
---
**Finding Lane Lines on the Road**

The goals / steps of this project are the following:
* Make a pipeline that finds lane lines on the road
* Reflect on your work in a written report

[//]: # (Image References)

[image1]: ./examples/grayscale_image.jpg "Grayscale"
[image2]: ./examples/blurred.jpg "Gaussian"
[image3]: ./examples/Canny_transform.jpg "Canny Transform"
[image4]: ./examples/masking_with_region_of_interest.jpg "Region of Interest"
[image5]: ./examples/lane_lines_mask.jpg "Lane Lines on mask"
[image6]: ./examples/lane_lines_final.jpg "Lane Lines on Image"
---

### Reflection

### 1. Lane Line Detection Pipeline

To effectively detect lane lines using Computer Vision Techniques, I chose the following sequence

 * **Convert the Image to Grayscale**

    It is always easier to work on 2-channel images than 3-channel images
    ![image1]

* **Apply Gaussian Blur as Low pass filter**

    Gaussian Blur is used to remove noise in an Image and smooth the images.
    ![image2]

* **Apply Canny Edge Detection**

    Canny Edge Detection is used to detect edges. It detects parts of image where there is a abrupt shift in intensity.
    ![image3]

* **Selecting region of Interest**

    Now we select region of interest in which we want to find lane lines.
    I use a quadrilateral region
    ![image4]

* **Hough Transform**

    Hough Transform is used to detect lines and other polygons in the image.
    In this we used houghlines() functions to detect straight lines.
    Hough Transform uses hough space to detect common / intersecting points in sinusoidal curves which are the representation of straight lines in cartesian plane.
    ![image5]

* **Overlay the Original image with the lane lines**

    addweighted() function of opencv is used to multiply the original image with a smaller factor and then adding it to the lane lines in black image , so that lane lines have more intensity in the resultant image.
    ![image6]

### 2. Potential Shortcomings in this approach

*  This Approach doesnt handle cases of curved lane lines

### 3. Possible improvements to the pipeline

* Polylines() function of opencv might overcome this shortcoming


text:
---
layout: page
title: Projects
---

Have a look at my [GitHub](https://github.com/trailblazerr1/)

You could find for example:

- [imsify](https://github.com/Trailblazerr1/iiita-hacks-musify): Makes playlists according to your mood.

- [faceme](https://github.com/Trailblazerr1/FaceMe): When facebook starts revealing secrets.

- [imsearch](https://github.com/Trailblazerr1/imsearch): Stop scrolling! ask for photos.

- [book search](https://github.com/Trailblazerr1/advanced-library-book-search) A search tool for college's library

Page is under construction...