text:
# windows-terminal-quake
Companion program for the new Windows Terminal that enables Quake-style drop down. Forked from original work by [flyingpie](https://github.com/flyingpie/windows-terminal-quake)

![Preview](https://files.flyingpie.nl/windows-terminal-quake.gif)

- Runs alongside the new Windows Terminal
- Toggle using CTRL+~ or CTRL+Q
- Shows up on the screen where the mouse is (eg. multi-monitor and multi-workspace)

## Usage
There are a couple of options:

- Download the latest release from the [releases page](https://github.com/flyingpie/windows-terminal-quake/releases).
- Clone/download the source and run **build.ps1**.
- Clone/download the source and build using Visual Studio.

## Features

- Persists window dimensions between sessions
- Pressing hotkey when terminal window is not foreground will bring it to foreground; otherwise it will "slide out"
- Pressing hotkey when terminal window is minimized will "slide in"
- Relaunching `windows-terminal-quake` will also give focus to active terminal window

## Known issues/limitations

- Some minor flicker when restoring window after a "minimize"
- Should support features like "fit width", hover, etc
- Probably will not be improved much except to fix really bad bugs, since it's expected that Windows Terminal will probably natively support this/similar much-requested feature

repository: jamietre/windows-terminal-quake

gha_language: C#

repo_name: jamietre/windows-terminal-quake


text:
# AWS CLI Lambda

This is a full working example of executing the AWS CLI script in a Lambda.

> Yup, there's boto and a AWS SDK in most languages, but I needed the AWS CLI specifically.

## TLDR

The meat of "how to do this" is mostly:

* [docker/build/Dockerfile#L7](docker/build/Dockerfile#L7)
* [src/index.py](src/index.py)

The rest is boiler plate to get it to "run" via command line args from an `aws lambda invoke`.

## Build/Deploy

The build and deploy steps are done in Docker so files are compiled with an environment like where
it will be deployed to. Assuming you've configured your `local.env`, just use `docker-compose` to
kick off a build _and_ a deploy to AWS (SAM app).

### Configure `docker/build/local.env`

Edit `docker/build/local.env` to taste using
[docker/build/local.dist.env](docker/build/local.dist.env) as a template.

```
AWS_ACCESS_KEY_ID=ABC123
AWS_DEFAULT_REGION=us-east-1
AWS_SECRET_ACCESS_KEY=000111222333444555666778899aaabbcccddee

ENV_NAME=dev
APP_NAME=awscli

# Create with `aws s3 mb <bucketname>` if you don't have a S3 bucket handy.
# This is used to push the zip'ed Lambda code to S3 so a Lambda can be deployed.
S3_BUCKET=my-scratch-foo
```

### Kick of Build/Deploy

```shell
cd docker/build
docker-compose up --build
```

## Invoke Lambda

To test, invoke the Lambda and check Cloud Watch logs if you did not receive output resembling
the expected output for `s3 ls` output.

```shell
aws lambda invoke \
    --function-name dev-aws-cli \
    --payload '{"cmd": "s3 ls"}' \
    /dev/stdout
```

license: MIT

repository: LyleScott/aws-cli-lambda

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: LyleScott/aws-cli-lambda


text:
---
id: iam-Mobile Analytics
title: Mobile Analytics
desc: ''
updated: '0'
created: '0'
stub: false
toc: true
sources:
  - name: Policy Sentry
    url: 'https://github.com/salesforce/policy_sentry'
    license: MIT
---
# Mobile Analytics
- prefix: mobileanalytics

## Table of Contents

## Privileges
### GetFinancialReports
- description: Grant access to financial metrics for an app
- access level: Read
- resource types
```
{
    "": {
        "resource_type": "",
        "required": false,
        "condition_keys": [],
        "dependent_actions": []
    }
}
```
### GetReports
- description: Grant access to standard metrics for an app
- access level: Read
- resource types
```
{
    "": {
        "resource_type": "",
        "required": false,
        "condition_keys": [],
        "dependent_actions": []
    }
}
```
### PutEvents
- description: The PutEvents operation records one or more events
- access level: Write
- resource types
```
{
    "": {
        "resource_type": "",
        "required": false,
        "condition_keys": [],
        "dependent_actions": []
    }
}
```

repository: dendronhq/dendron-vault-aws

branch_name: refs/heads/main

repo_name: dendronhq/dendron-vault-aws


text:
# VisualSQL

Is a visual tool that allows you to use relational algebra operators to interact with a real database. Built in support for MySQL.

Wiki: [Relational Algebra(Wiki)](https://en.wikipedia.org/wiki/Relational_algebra)

## Getting Started

After building the application VisualSQL can be started from the bat file VisualSQL.bat.

* First step is to create a connection.

![Configure Connection](img/connection-config.png)

After crating the connection you will have to select it for it to be considered active.

* Now lets create a diagram by the selecting  operators and tables from the left panels. The generated SQL and the values are presented right below.

![Diagram](img/diagram.png)

A table with the result is also displayed.

![Diagram - table](img/table.png)

### Prerequisites

The tool was developed as an Applet using Java 6.

We have a simple stack:
* Java 6
* Applet
* MySQL (embedded driver)
* JDOM
* Maven

### Installing

To build and generate the distribution Jar-file:
```
mvn package
```

## Running the tests

```
mvn test
```

## License

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

repository: edusasse/VisualSQL

repo_name: edusasse/VisualSQL


text:
# What's this?

Communication between Activity and Fragment using Android Architecture Components ViewModel.

# Host Activity with ViewPager

https://github.com/sys1yagi/aac-viewmodel-with/tree/master/app

# Host Activity with DialogFragment

https://github.com/sys1yagi/aac-viewmodel-with/tree/master/fragment-dialog

repository: nandgreat/aac-viewmodel-with

repo_name: nandgreat/aac-viewmodel-with


text:
# Writing a Post-Authentication Handler

WSO2 Identity Server authentication framework facilitates you with the
pluggable architecture of multiple inbound/outbound protocols as well as
local and federated authenticators including a large number of extension
points. The Post Authentication Handler is one such extension point
which allows you to do a task upon successful authentication.
Authentication to the system is only successful once the execution of
post-authentication handlers is completed. The following handlers are
examples of post-authentication handlers that are available by default.

-   **Application authorization handler** - Once the user successfully
    authenticates to a service provider, this authorization handler will
    check whether the given user is entitled to login by evaluating a
    xacml policy. This happens during authorization.

-   **Missing mandatory claim handler** - When mandatory claims are
    configured in a service provider under claim configurations, the
    user is prompted to fill in mandatory claim values if the values are
    not already known at the point of authentication.

-   **Consent handler / disclaimer dialog** - This handler requests for
    either consent or disclaimer approval. Once the authentication steps
    are completed, the user is prompted for consent or disclaimer
    approval and the user is only able to proceed once it is accepted or
    approved.

### Writing a post-authentication handler

Writing a custom post-authentication handler is fairly simple. For a
sample implementation consisting of the disclaimer dialog, see the
[sample post-authentication
handler](https://github.com/wso2/samples-is/tree/master/etc/sample-post-authentication-handler)
. Follow the instructions on the readme to try it out.

Extend the
`         org.wso2.carbon.identity.application.authentication.framework.handler.request.AbstractPostAuthnHandler        `
to write a custom handler. This allows you to enable/disable or change
the priority of this handler via configurations in
`         identity.        ` xml configuration file. The
post-authentication handler interface consists of a single main method
which you need to implement in order to implement a post-authentication
handler.

``` java
PostAuthnHandlerFlowStatus handle(HttpServletRequest httpServletRequest,

    HttpServletResponse httpServletResponse,

    AuthenticationContext authenticationContext)

throws PostAuthenticationFailedException;
```

The post-authentication operations can be done within the implementation
of this handler. The response can be coveyed on the interface using one
of the following two methods.

##### By returning a PostAuthnHandlerFlowStatus

This method of returning the response can have multiple flow statuses:

Status
Description

SUCCESS_COMPLETED
This status can be returned if the post-authentication process is complete. The next post handler is then invoked as the current one has been completed.

INCOMPLETE

This status indicates that the post-authentication process is incomplete (e.g., a redirection to an external page). The response can be simply redirected and you can expect it to come back to your post-authentication handler once the response is submitted to WSO2 IS again.

If a response from an external page is submitted to the post-authentication handler which is in progress, the following needs to be included in the request along with the input data that is recieved from the external page:

SessionDataKey

Note

The 'sessionDataKey' query parameter is used to coordinate the request state across components participating in the request flow. It does not correlate with the user session. Furthermore, the request state maintained against the 'sessionDataKey' parameter value is cleared by each participating component at the end of request flow. This means that even if an external party grabs the 'sessionDataKey' they will not be able to get into the authentication sequence, as the user session is not associated with that key.

PASTR cookie (this is used to track the post-authentication sequence and used to secure the post-authentication flow.)

As seen in the sample implementation, the disclaimer page is redirected
and it stores the “consentPoppedUp” state so that next time the post
handler continues upon the response, it can look for the disclaimer
response and proceed.

##### By throwing a PostAuthenticationFailedException

A post-authentication exception along with an error code and message can
be thrown if you wish to break the login flow or do not need to continue
the login flow. The error code will be displayed in an error page. For
example, this exception can be used for failing a login attempt due to
an authorization failure.

Follow the steps given in the [sample post-authentication handler
readme](https://github.com/wso2/samples-is/blob/master/etc/sample-post-authentication-handler/README.MD)
to install this sample and get it working with WSO2 Identity Server. You
can enable and disable this newly written handler using the
configuration shown below in the `
<IS_HOME>/repository/conf/deployment.toml ` . You can also change the
execution order using the ` order ` parameter. The handler with the
lesser value for the ` order ` parameter will be executed first.

```toml
[[event_listener]]
id = "custom_post_auth_listener"
type = "org.wso2.carbon.identity.core.handler.AbstractIdentityHandler"
name = "org.wso2.carbon.identity.post.authn.handler.disclaimer.DisclaimerPostAuthenticationHandler"
order = 899
```

!!! note

    **Note:** These configurations will not be effective if the
    `          getPriority         ` and `          isEnable         `
    methods of your post authentication handler are overridden.

repository: NipuniBhagya/docs-is

repo_name: NipuniBhagya/docs-is


text:
# Changelog
All notable changes to this project will be documented in this file.

The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).

## Unreleased

## [v0.2.6] - 2021-01-25
### Changed
- Update font8x8 to v0.2.7.

## [v0.2.5] - 2020-06-17
### Changed
- Updated minimal rust version to v1.32.0
- Ran `cargo fix --edition`, with minor changes to `src/fram_clip.rs`,
  `src/frame_offset.rs`, and `src/frame_rotate.rs`.

### Added
- `edition = "2018"` under `[package]` in Cargo.toml.
- `1.32.0` toolchain to .travis.yml

## [v0.2.4] - 2020-06-15
### Changed
- Update framebuffer to v0.2.0.
- Run `cargo fmt` throughout.
- Removes `FontString::to_string` and implements `fmt::Display` as suggested
  by the `clippy::inherent_to_string_shadow_display` lint.

### Removed
- `rustfmt.toml`
- `clippy::into_iter_on_ref` lint.
- `clippy::len_without_is_empty` lint.
- `clippy::trivially_copy_pass_by_ref` lint.
- `clippy::inherent_to_string_shadow_display` lint. This removes `FontString::to_string`
  and implements `fmt::Display`.

## [v0.2.3] - 2019-06-07
### Changed
- Version for font8x8 to v0.2.5. Addresses https://github.com/rust-lang/rust/issues/61478

## [v0.2.2] - 2018-07-23
### Added
- New `error::ScreenError` type to handle crate errors.

### Fixed
- Avoid unnecessary allocations when initializing `FONT_COLLECTION`.

### Changed
- Use 'font8x8 = 0.2.3' with new `UnicodeFonts::iter` method.

## [v0.2.1] - 2018-07-20
### Fixed
- Correct version in Usage section of README.md

## [v0.2.0] - 2018-07-20
### Added
- `lazy_static = "1.0"` to Cargo.toml.
- Lazily-initiated static `fonts::FONT_HASHMAP` exported in top-level.
- Lazily-initiated static `fonts::FONT_COLLECTION` exported in top-level.

### Changed
- Update to `font8x8 = 0.2` in Cargo.toml.
- Replace `FontUtf16` with `FontUnicode` type.
- Replace `Utf16Fonts` with `UnicodeFonts` trait.
- Replace `u16` with `char`.
- Replace `FontString::encode_utf16` with `FontString::chars` method (breaking change).
- Update examples to use new Fonts API.
- `examples/letter.rs` uses `FONT_COLLECTION` instead of manually setting up a `FontCollection`.
- `examples/clip.rs` uses `FONT_COLLECTION` instead of manually setting up a `FontCollection`.

### Removed
- `fonts::print_collection` function.

## [v0.1.11] - 2018-06-17
### Fixed
- URLs to `examples/scroll-*.rs` on README.

## [v0.1.10] - 2018-06-17
### Added
- `BackgroundColor` trait defines setter/getter of background color.
- `StrokeColor` trait defines setter/getter of stroke color.
- Unit tests and documentation for:
  * `FontString::new`
  * `FontString::encode_utf16`
  * `FontString::to_string`
- `scroll` trait to join a collection of `PixelFrame`s into a single `Scroll`.
- `Scroll` type to wrap an inner `Vec<PixelFrame>`.
  * `Scroll::new(&[PixelFrame])` method initializes a scroll.
  * `Scroll::clips` method returns a `Vec<Clip>` made from the inner `Vec<PixelFrame>`.
  * `Scroll::frames` method returns a slice of the inner `Vec<PixelFrame>`.
  * `Scroll::reverse` method reverses the order of the inner `Vec<PixelFrame>`.
  * `Scroll::len` method the length of the inner `Vec<PixelFrame>`.
- Tests and implementation for new `FontFrame` type, which is a font with stroke and background colors:
  * `FontFrame::new`
  * `FontFrame::pixel_frame`
- `PixelFrame` implements `From<FontFrame>`.
- `FontFrame` implements `BackgroundColor` trait.
- `FontFrame` implements `StrokeColor` trait.
- New `basic` features are a subset of the current the `default` feature list.
- Add Travis CI integration with `.travis.yml`.
- Badge for Travis CI in README.md
- Add "Requirements" section to README.md.
- Specify Rust stable v1.26 as the minimum version requirement on README.md
- Tests for `Scroll` instances that create `FrameSequence` with a given `FrameDirection`.
  * `Scroll::right_to_left` for `FrameDirection::RightToLeft`.
  * `Scroll::left_to_right` for `FrameDirection::LeftToRight`.
  * `Scroll::top_to_bottom` for `FrameDirection::TopToBottom`.
  * `Scroll::bottom_to_top` for `FrameDirection::BottomToTop`.
- Add "Changelog" section to README.md, linking to this document.
- Add `FrameSequence` type.
- Add `examples/scroll-top-bottom.rs`.
- Add `examples/scroll-bottom-top.rs`.
- Add `examples/scroll-left-right.rs`.
- Add `examples/scroll-right-left.rs`.
- Add descriptions to examples on README.md.
- Add scroll examples to README.md

### Changed
- `FontString` wraps `Vec<font8x8::FontUtf16>` instead of `Vec<u16>`.
- Updated `examples/letter.rs` to use new `FontString::encode_utf16` method.
- Refactored `basic` features in the `default` feature list.
- `sensehat_screen::{Offset, clip_pixel_frames_offset_left, clip_pixel_frames_offset_top}` now have the `#[cfg(any(feature = "offset", feature = "clip"))]` attribute.

### Removed
- `rotate_bytes_left` and `rotate_bytes_right` implementation functions in `src/frame_clip.rs` are no longer needed.
- Duplicate badge for Cargo Docs from `README.md`.

## [v0.1.9] - 2018-05-01
### Added
- "Contribute" section in `CHANGELOG.md` to invite people to contribute to this library.
- `rustfmt.toml`, sets the expected `indent_style` to be `Visual`
- `impl<'a> From<&'a [PixelColor; 64]> for PixelFrame`
- `impl From<[PixelColor; 64]> for PixelFrame`
- `impl Into<[PixelColor; 64]> for PixelFrame`
- `impl Index<usize> for PixelFrame`, to get pixel colors using `let color = pixel_frame[idx]`-style syntax.
- `impl IndexMut<usize> for PixelFrame`, to set pixel colors using `pixel_frame[idx] = color`-style syntax.

### Changed
- Ran `cargo fmt` with `index_style` set to `Visual`

## [0.1.8] - 2018-04-30
### Fixed
- `font_to_frame` and `font_to_pixel_frame` methods were using incorrect indexes.

### Changed
- Update `README.md` section for examples, making it friendlier to read.

## [0.1.7] - 2018-04-29
### Added
- `CHANGELOG.md` has a header, and conforms to [Keep a Changelog](http://keepachangelog.com/en/1.0.0/).
- `clip` feature to combine PixelFrames
- `frame::Clip` struct that combines two PixelFrame and returns a clip of them. Fully documented and tested.
- `PixelFrame::clip` method to create a clip frame on-the-go.
- `PixelFrame::build_clip` method to build a clip, suitable for loops, and when multiple clips of the same frames are needed.
- `examples/text-clip.rs` shows how to scroll two frames, by creating clip and rendering them on the screen.
- `Rotate` enum provided a strongly-typed rotation angle for frames.
- Top-level documentation describes what crate types do in `src/lib.rs`.
- Top-level re-export of `Rotate`, `Offset`, and `Clip`.
- Fine-tuning of frame clipping doctests.
- `PixelFrame::transpose` method to transpose LED Matrix indexes.
- `PixelFrame::flip_h` method to horizontally flip the LED Matrix.
- `PixelFrame::flip_v` method to vertically flip the LED Matrix.
- `PixelFrame::reverse` method to reverse the LED Matrix indexes.

### Changed
- `default` features now also include: `clip`.
- `offset` feature now depends on `clip`.
- refactor font-related code into `src/fonts.rs`.
- rename `PixelColor::from_rgb565` to `PixelColor::from_rgb565_bytes` for clarity.
- replace inner `Vec<u8>` with `[Rgb565; 64]` in `FrameLine`.
- replace inner `Vec<PixelColor>` with `[PixelColor; 64]` in `PixelFrame`.
- rename `FrameLine::as_slice` to `FrameLine::as_bytes`
- `PixelFrame::as_rows` method now returns `&[[PixelColor; 8]; 8]`.
- `PixelFrame::as_columns` method now returns `&[[PixelColor; 8]; 8]`.
- `PixelFrame::from_rows` method now takes `[[PixelColor; 8]; 8]`.
- `PixelFrame::from_columns` method now takes `[[PixelColor; 8]; 8]`.
- Optimize `rotate`, `offset`, and `clip`  methods with slice methods and iterators.

## [0.1.6] - 2018-04-22
### Added
- `offset` trait to render `PixelFrame` with offset.
- `PixelFrame::offset` method creates a PixelFrame with the visible parts of the offset original. Features comprehensive testing.
- `frame::Offset` enum wraps an offset from `0..=8` in four directions:
    * `Offset::Left(_)`
    * `Offset::Right(_)`
    * `Offset::Top(_)`
    * `Offset::Bottom(_)`

  which may only be created by the associated methods:

    * `Offset::left(offset: u8)`
    * `Offset::right(offset: u8)`
    * `Offset::top(offset: u8)`
    * `Offset::bottom(offset: u8)`

  all with comprehensive testing.

- `PixelFrame::as_rows` method. Features comprehensive testing.
- `PixelFrame::as_columns` method. Features comprehensive testing.
- `PixelFrame::from_rows` method. Features comprehensive testing.
- `PixelFrame::from_columns` method. Features comprehensive testing.

### Changed
- `default` features now also include: `rotate`, and `offset`.
- Updated features on `README.md`.
- Lots of module refactoring with no change to API.

## [0.1.5] - 2018-04-15
### Added
- `Rgb565` type to separate concerns from `PixelColor`, and properly encode/decode RGB565 colors.
- `big-endian` feature to encode Rgb565 colors in big-endian format.
- `Rgb565` implements From<_> and Into<_> for `PixelColor`, `&PixelColor`, `(u8, u8, u8)`, and [u8; 2]`.
- `PixelFrame` type to represent a single LED matrix screen frame.
- `rotate` feature to rotate a `PixelFrame` by steps of 90-degrees.
- `examples/rotating-symbol.rs` to demo rotating font symbols with color.

### Changed
- Framebuffer-related code refactored into `sensehat_screen::screen` module.
- `FrameLine`-related code refactored into `sensehat_screen::frame` module.
- Make crate modules public.
- `FrameLine` defaults to little-endian format.
- Update `README.md` and `src/lib.rs` documentation.

## [0.1.4] - 2018-04-08
### Added
- Implement `Copy` trait for `PixelColor`.
- `PixelColor::dim` method to dim the color by a factor between 0 and 1.
- Color constants:

    * `RED`
    * `BLUE`
    * `MAGENTA`
    * `BLACK`
    * `RED`
    * `BLUE`
    * `GREEN`
    * `WHITE`
    * `YELLOW`
    * `CYAN`
    * `MAGENTA`

- Update pixel color usage on tests, examples, and `README.md`
- Speed-up printing letter in `examples/letter.rs`, showing one character every 800ms.

## [0.1.3] - 2018-04-05
### Added
- Doctest with example on `src/lib.rs`.
- Update README with a copy of the `src/lib.rs` doctest example.
- Implement `Debug` and `Default` trait for `FontString`.
- Implement `PartialEq` trait for `PixelColor`, `FrameLine`, `FontCollection`, `FontString`.
- Implement `Clone` trait for `PixelColor`, `FrameLine`, `FontCollection`, `FontString`.

### Changed
- Renamed private constant from `BLACK` to `LED_OFF`.

## [0.1.2] - 2018-04-02
### Changed
- updated `README.md` with the newest features

## [0.1.1] - 2018-04-02
### Added
- `serde-support` feature in Cargo.toml to enable `serde` support.
- `linux-framebuffer` feature in Cargo.toml to optionally use the Screen.
- `default` feature includes `serde-support`, and `linux-framebuffer`
- `CHANGELOG.md` for semantic-versioning of changes (this file).

## [0.1.0] - 2018-04-01
### Added
- `PixelColor` type to represent an RGB color, renderable into RGB565.
- `FrameLine` type to write bytes into the `Screen` framebuffer.
- `Screen` type to open the framebuffer and write frames.
- `FontCollection` and `FontString` types, to manipulate fonts compatible with the `Screen`.
- `font_to_frame` convenience function to render a font as a `FrameLine`.
- `print_collection` convenience function to list a `FontCollection` on stdout.
- `fonts` feature in Cargo.toml. Conditional compilation attributes for font types and functions.
- `default` feature includes `fonts`
- `examples/blink.rs` shows how to manually write frames to the screen.
- `examples/letter.rs` shows how to render a sanitized-text on the screen.

repository: CubixSystem/sensehat-screen-rs

repo_name: CubixSystem/sensehat-screen-rs


text:
# Editorconfig

Editorconfig is a standard to define some editor settings in a compatible way.

Supported editors:

- Jetbrains products (IntelliJ IDEA, WebStorm, PyCharm, CLion, etc.)
- Atom: _TODO_: Check if it requires a plugin
- Eclipse: requires a plugin

## References

- http://editorconfig.org

license: Unlicense

repository: demurgos/notes

repo_name: demurgos/notes


text:
<!--
Hello! You are about to create an issue in ipfs-cluster. We ask you to please read and complete the following template.

Note: it might be easier to just click on these check boxes right after creating the issue.
-->

#### Pre-check

* [x] This is not a IPFS Cluster website content issue ([file those here](https://github.com/ipfs/ipfs-cluster-website/issues))
* [x] I read the [troubleshooting section](https://cluster.ipfs.io/documentation/troubleshooting/) of the website and it did not help
* [x] I searched for similar issues in the repo without luck
* [x] All my peers are running the same cluster version
* [x] All my peers are configured using the same cluster `secret`

#### Basic information

* [x] Version information (mark as appropiate):
  * [ ] Master
  * [ ] Release candidate for next version
  * [ ] Latest stable version
  * [ ] An older version I should not be using
* [x] Type (mark as appropiate):
  * [ ] Bug
  * [ ] Feature request
  * [ ] Enhancement
* [x] Operating system (mark as appropiate):
  * [ ] Linux
  * [ ] macOS
  * [ ] Windows
  * [ ] Other: `which?`
* [x] Installation method (mark as appropiate):
  * [ ] Binaries from dist.ipfs.io
  * [ ] Built from sources
  * [ ] Docker
  * [ ] Snap
  * [ ] Other: `which?`

#### Description

<!--
Include a description of the problem or the feature.

When reporting a bug, please try to include:

* What you were doing when you experienced the bug.
* Any relevant log messages (and the peers they belong to if you have logs for several peers).
* When possible, steps to reproduce the bug.
-->

repository: kishansagathiya/ipfs-cluster

gha_license_id: MIT

repo_name: kishansagathiya/ipfs-cluster


text:
# Circulate Hashed Data Collection for Node.js

This is a library to aid in the implementation of [Circulate](http://www.circulate.com) hashed data colection. This library hashes data and builds the HTML placement for adding to a webpage or in an email for ad tracking. It also provides convenience for dealing with cookies.

## Installation

```sh
$ npm install node-circulate
```

## API

### getHtml(siteId, userData)

Generates the the Circulate HTML placement. The "email" value should be the hashed email from hashEmail()

```
@param <number> siteId - site identifying key
@param <object> userDatda - Object representation of user data
@return <String> - email address hashed using Circulate's algorithm
```

### hashEmail(email)

Gets the Circulate email hash string

```
@param <string> email - email address
@return <string> - email address hashed using Circulate's algorithm
```

### expressSetCookie(response, path, domain)

Convenience method for setting Circulate cookie when using Express framework

```
@param <object> response - Express Response object
@param <string> path - (Optional) Cookie path
@param <string> domain - (Optional) Cookie domain
@return <undefined>
```

### expressGetCookie(request)

Convenience method for getting Circulate cookie when using Express framework. NOTE: This requires that the cookie-parser middleware be loaded.

```
@param <object> request - Express Request object
@return <undefined>|<object> - Cookie value if set; undefined otherwise
```

## Example

```js
myExpressController = function(request, response, next) {
  var circulate = require('./index'),
    hashedEmail,
    circulatePlacement;

  // Hash email with Circulate algorithm
  hashedEmail = circulate.hashEmail('fdsafdsaf@gmail.com'),

  // Get HTML placement
  circulatePlacement = circulate.getHtml('site123', {hema: hashedEmail});

  // Add cookie to response
  circulate.expressSetCookie(response);

  // Send the response
  response.render('/myView', {circulatePlacement: circulatePlacement})
}
```

## Disclaimer

*NOTE:* This is a third-party, open source library developed by [Path Evolution, LLC](http://pathevolution.com/) and is not officially supported by [Circulate.com, Inc.](http://www.circulate.com). This project is licensed under Apache License 2.0.

repository: userenroll/node-circulate

gha_language: JavaScript

repo_name: userenroll/node-circulate


text:
AspNet.Security.OpenIdConnect.Server
==================================

**AspNet.Security.OpenIdConnect.Server** is an **advanced OAuth2/OpenID Connect server framework** for ASP.NET 5, designed to offer a low-level, protocol-first approach.

**The latest official release can be found on [NuGet](https://www.nuget.org/packages/AspNet.Security.OpenIdConnect.Server) and the nightly builds on [MyGet](https://www.myget.org/gallery/aspnet-contrib)**.

[![Build status](https://ci.appveyor.com/api/projects/status/tyenw4ffs00j4sav/branch/vNext?svg=true)](https://ci.appveyor.com/project/aspnet-contrib/aspnet-security-openidconnect-server/branch/vNext)
[![Build status](https://travis-ci.org/aspnet-contrib/AspNet.Security.OpenIdConnect.Server.svg?branch=vNext)](https://travis-ci.org/aspnet-contrib/AspNet.Security.OpenIdConnect.Server)

## Get started

Based on `OAuthAuthorizationServerMiddleware` from **Katana 3**, **AspNet.Security.OpenIdConnect.Server** exposes similar primitives and can be directly registered in **Startup.cs** using the `UseOpenIdConnectServer` extension method:

```csharp
app.UseOpenIdConnectServer(options => {
    options.Provider = new OpenIdConnectServerProvider {
        // Implement OnValidateClientRedirectUri to support interactive flows like code/implicit/hybrid.
        OnValidateClientRedirectUri = context => {
            if (string.Equals(context.ClientId, "client_id", StringComparison.Ordinal) &&
                string.Equals(context.RedirectUri, "redirect_uri", StringComparison.Ordinal)) {
                context.Validate();
            }

            return Task.FromResult(0);
        }

        // Implement OnValidateClientAuthentication to support flows using the token endpoint.
        OnValidateClientAuthentication = context => {
            if (string.Equals(context.ClientId, "client_id", StringComparison.Ordinal) &&
                string.Equals(context.ClientSecret, "client_secret", StringComparison.Ordinal)) {
                context.Validate();
            }

            return Task.FromResult(0);
        }
    };
});
```

## Samples

**Official samples targetting ASP.NET 5 RC1** can be found on [aspnet-contrib/AspNet.Security.OpenIdConnect.Samples](https://github.com/aspnet-contrib/AspNet.Security.OpenIdConnect.Samples).

**Looking for something simpler?** Don't miss **[OpenIddict](https://github.com/openiddict/core)**, the **simple and easy-to-use OpenID Connect server for ASP.NET 5** based on AspNet.Security.OpenIdConnect.Server and ASP.NET Identity 3.

## Support

**Need help or wanna share your thoughts?** Don't hesitate to join our dedicated chat rooms:

- **JabbR: [https://jabbr.net/#/rooms/aspnet-contrib](https://jabbr.net/#/rooms/aspnet-contrib)**
- **Gitter: [https://gitter.im/aspnet-contrib/AspNet.Security.OpenIdConnect.Server](https://gitter.im/aspnet-contrib/AspNet.Security.OpenIdConnect.Server)**

## Contributors

**AspNet.Security.OpenIdConnect.Server** is actively maintained by **[Kévin Chalet](https://github.com/PinpointTownes)**. Contributions are welcome and can be submitted using pull requests.

## License

This project is licensed under the **Apache License**. This means that you can use, modify and distribute it freely. See [http://www.apache.org/licenses/LICENSE-2.0.html](http://www.apache.org/licenses/LICENSE-2.0.html) for more details.

branch_name: refs/heads/vNext


text:
# Azure Container Registry
Terraform module to create ACR

# Usage
```
module "acr" {
        source  = "github.com/iquzart/terraform-azurerm-acr"
        #version = "0.x.y"

        name                      = "ACR Name"
        resource_group_name       = "Resource Group Name"
        location                  = "Resource Location"
        sku                       = "ACR SKU"
        admin_enabled             = "true od false"
        georeplication_locations  = "Georeplication locations (premium SKU)"
        tags                      = "Resource Tags"
}

```

# Variables
```
variable "name" {
    description = "(Required) Specifies the name of the Container Registry. Changing this forces a new resource to be created."
}

variable "resource_group_name" {
    description = "(Required) The name of the resource group in which to create the Container Registry. Changing this forces a new resource to be created."
}

variable "location" {
    description = "(Required) Specifies the supported Azure location where the resource exists. Changing this forces a new resource to be created."
}

variable "admin_enabled" {
    description = "(Optional) Specifies whether the admin user is enabled. Defaults to false."
    default = true
}

variable "sku" {
    description = "(Optional) The SKU name of the the container registry. Possible values are Basic, Standard and Premium. Default = Basic"
    default = "Basic"
}

variable "tags" {
    description = "(Optional) A mapping of tags to assign to the resource."
    default = {}
}

variable "georeplication_locations" {
    description = "(Optional) A list of Azure locations where the container registry should be geo-replicated."
    default = null
}
```

# License
MIT

repository: iquzart/terrafom-azurerm-aks

repo_name: iquzart/terrafom-azurerm-aks


text:
# mm-oberbank
[MoneyMoney](https://moneymoney-app.com/) is a personal book keeping software for macOS. It is able to fetch bank statements from bank accounts automatically if the bank provides a HBCI/FinTS API. That includes most german banks.

For Banks who don't support HBCI/FinTS (which is most non-german banks) MoneyMoney provides a Lua scripting engine for building scraper extensions for web banking.

**mm-oberbank** is such an extension for the austrian **Oberbank**.

**NOTE: This extension can only be used in Beta versions of MoneyMoney**

For security reasons MoneyMoney only lets you use signed extensions. This extension **does not** have a signature. However you can stil use it by deactivating the signature check, but this can only be done in Beta-Versions of MoneyMoney.

## Installation

### Get a Beta Version

For reasons explained above this extension only works with Beta Versions of MoneyMoney. To get a Beta version activate the flag _Participate in beta tests and display pre-release versions_ in the general preferences.

### Install the extension

* Open MoneyMoney and open the preferences (`Cmd + ,`)
* In the _Extensions_ tab deactivate the flag _Verify digital signatures of extensions_
* Select from the menu *Help > Show Database in Finder*
* Take the file `Oberbank.lua` from this Repo and place it in the `Extensions` folder
* A new account type _Oberbank_ should instantly show up in the _Add account_ dialog.

repository: kolomanschaft/mm-oberbank

repo_name: kolomanschaft/mm-oberbank


text:
# Setting up local clusters
### Install required plugins
```
$ vagrant plugin install vagrant-triggers
$ vagrant plugin install vagrant-hostsupdater
```

The scripts here will set up a single node or a multi-node cluster with the following services installed:
```
1. Zookeeper
2. Mesos-master
3. Marathon
4. Mesos-slave
5. Docker
```
These are provided as examples with vagrant VMs. You could set up your own inventory of machines and run these scripts to get an actual cluster up and running. You can look at the definition of inventory files at
```
/vagrant/single_node/hosts/single
/vagrant/multi_node/hosts/localmesos-cluster
```

These setups also serve as a local test cluster for development purposes.

## Single-Machine cluster setup

### Setup:
1. `cd vagrant/single_node`
2. `vagrant up`
3. Verify that your local machine's `/etc/hosts` file has the entry: `<IP_ADDRESS>  localmesos01`
4. Install ansible - `sudo pip install ansible` (Note: Ansible can also be installed through the command line using brew or from the web.)
6. `./setup-single-node.sh` (both password and username is `vagrant`).
7. `http://localmesos01:5050` - ensure mesos is running.
8. `http://localmesos01:8080` - ensure marathon is running.
9. The file `/etc/mesos-master/zk` should have the following content for all the hosts:
```
zk://localmesos01:2181/mesos
```
10. The file `/etc/mesos-slave/master` should have the following content for all the hosts except localmesos01:
```
zk://localmesos01:2181/mesos
```

## Multi-node cluster setup

### Setup:
1. `cd roger/vagrant/multi_node`
2. `vagrant up`
3. Verify that your local machine's `/etc/hosts` file have the following entries:
```
   <IP_ADDRESS>  localmesos02
   <IP_ADDRESS>  localmesos03
   <IP_ADDRESS>  localmesos04
```
5. Install ansible. eg. `sudo pip install ansible` Note: Ansible can also be installed through the command line using brew or from the web.
6. `sh setup-multi-node.sh` (both username and password is `vagrant`.)
7. `http://localmesos02:5050` - ensure mesos is running.
8. `http://localmesos02:8080`- ensure marathon is running.
9. `/etc/mesos-master/zk` should have
```zk://localmesos02:2181,localmesos03:2181,localmesos04:2181/mesos```
10. `/etc/mesos-slave/master` should have
```zk://localmesos02:2181,localmesos03:2181,localmesos04:2181/mesos```

## Develepor Notes:
1. You need to know the sudo password to clear known_host entry at the time of destroying vagrant.
2. You need to be around as you need to pass on the ssh password `vagrant` mutiple times when running the the script.
3. Check your `/data/zk/logs/zookeeper.log` for any `Address already in use` exception if you find your cluster having problems in master selection (zk is not functional.)
4. Use the restart services script to restart all the services on all the hosts if required.
5. If you just restart mesos-slave it should be fine as well if resources are not getting registered.

repository: mesosup/roger-mesos

repo_name: mesosup/roger-mesos


text:
# UI Tweaks

There are various things you can do to change the look and feel of your admin when using jazzmin, some are structural
changes

### UI Customizer

Jazzmin has a built in UI configurator, mimicked + enhanced from [adminlte demo](https://adminlte.io/themes/v3/index3.html),
that allows you to customise parts of the interface interactively.

To enable this, set `JAZZMIN_SETTINGS["show_ui_builder"] = True` and there will be an icon in the top right of the screen
that allows you to customise the interface.

![icon](./img/customise_icon.png)

When your happy with your customisations, press the "Show Code" button, and it will give you a code snippet to put
into your settings that will persist these customisations beyond page refresh.

### Themes
With the ui customiser enabled (see above), you can try out different bootswatch themes, and combine the theme with our
other UI tweaks.

#### Dark mode enabled
If you set `JAZZMIN_UI_TWEAKS["dark_mode_theme"]` to a dark theme, then users that have opted for dark mode on their
device will be served this theme instead of the one in `JAZZMIN_UI_TWEAKS["theme"]`

This is done using `prefers-color-scheme` in the CSS media attribute, see [here](https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-color-scheme)
for more information on the web standard

for example, to use `flatly` for all users that have no preference or prefer light mode, and `darkly` for those who opt
for dark mode on their device:

```
JAZZMIN_UI_TWEAKS = {
    ...
    "theme": "flatly",
    "dark_mode_theme": "darkly",
}
```

To force the use of a single theme regardless, just omit `dark_mode_theme` from your `JAZZMIN_UI_TWEAKS`

You can preview any of the available themes on your site using the UI Customizer (See above), or view them on bootswatch
below

#### Light themes
- default (Standard theme built on top of bootstrap)
- cerulean [preview](https://bootswatch.com/cerulean/)
- cosmo [preview](https://bootswatch.com/cosmo/)
- flatly [preview](https://bootswatch.com/flatly/)
- journal [preview](https://bootswatch.com/journal/)
- litera [preview](https://bootswatch.com/litera/)
- lumen [preview](https://bootswatch.com/lumen/)
- lux [preview](https://bootswatch.com/lux/)
- materia [preview](https://bootswatch.com/materia/)
- minty [preview](https://bootswatch.com/minty/)
- pulse [preview](https://bootswatch.com/pulse/)
- sandstone [preview](https://bootswatch.com/sandstone/)
- simplex [preview](https://bootswatch.com/simplex/)
- sketchy [preview](https://bootswatch.com/sketchy/)
- spacelab [preview](https://bootswatch.com/spacelab/)
- united [preview](https://bootswatch.com/united/)
- yeti [preview](https://bootswatch.com/yeti/)

#### Dark themes
- darkly [preview](https://bootswatch.com/darkly/)
- cyborg [preview](https://bootswatch.com/cyborg/)
- slate [preview](https://bootswatch.com/slate/)
- solar [preview](https://bootswatch.com/solar/)
- superhero [preview](https://bootswatch.com/superhero/)

Here are some screenshots of the themes in action, Use the UI Customizer (See above) to test them all

#### Darkly
```
JAZZMIN_UI_TWEAKS = {
    ...
    "theme": "darkly",
}
```
![icon](./img/theme_darkly.png)

#### Simplex
```
JAZZMIN_UI_TWEAKS = {
    ...
    "theme": "simplex",
}
```
![icon](./img/theme_simplex.png)

#### Sketchy
```
JAZZMIN_UI_TWEAKS = {
    ...
    "theme": "sketchy",
}
```
![icon](./img/theme_sketchy.png)

#### Slate
```
JAZZMIN_UI_TWEAKS = {
    ...
    "theme": "slate",
}
```
![icon](./img/theme_slate.png)

### DIY with custom CSS/JS

If there are things you need to do with CSS/JS, but want to avoid overriding the templates yourself, you can include a
custom CSS and/or JS file, just pass a relative path to your files e.g:

```
"custom_css": "common/css/main.css",
"custom_js": "common/js/main.js"
```

Into your jazzmin settings (Ensure these files can be found by the static file finder)

If you want to manually tweak CSS styles for a particular theme, you can start your CSS rule with
`body.theme-<themename>` e.g:

```
body.theme-darkly p {
    color: pink;
}
```

Or to target your `dark_mode_theme` wrap it like this:

```
@media (prefers-color-scheme: dark) {
    body.theme-darkly p {
        color: pink;
    }
}
```

repository: farridav/django-jazzmin

gha_language: HTML

repo_name: farridav/django-jazzmin


text:
# OpenCV kernels

## Overview
The HTML5 standard brings users the great capability of including and handling multimedia locally, together with an emerging need of computer vision programming functions available on the web. However, real-time user experience cannot be achieved when implementing those computation-intensive functions in JavaScript, even on the highly-optimized JavaScript engine. With the announcement of WebAssembly technology, source code in multiple programming languages, such as C, C++, Rust, etc. can be compiled into a sort of low-level and platform-independent bytecode which can run on the browsers while maintaining near-to-native execution speed. Thus, the widely-used OpenCV library can be ported to web platform with little extra effort, the ported library is officially called OpenCV.js.

The OpenCV-based applications relies on the kernel functions for the performance-critical work. This benchmark evaluates three vision kernels for image transformation, including: threshold, integral and cvtColor. The threshold function applies fixed-level thresholding to a single-channel array; the integral function calculates the integral of an image; the cvtColor converts an image from one color space to another. The reasons for their admission are:

1) they are representative kernels in OpenCV;
2) they are heavily used in the image-processing applications;
3) they are computation-intensive kernels which can reflect WebAssembly's performance and real user experience;
4) they are potential beneficiaries of WebAssembly SIMD or multi-thread features.

This benchmark runs each of the functions for 1000 times and measures the **prepare time**, **elapsed time** and **average time**, the standard deviations (**stddev**) are also calculated for stability analysis. Among the metrics we evaluate, **prepare time** and **elapsed time** are the dominant ones, and others are only for reference. In the tail of all 1000 runs, sha256 checksum of output image is calculated and compared with the reference value. By setting the size of images as 640\*480, 1280\*720 and 1920\*1080, the benchmark runs in small, medium and large mode respectively.

## Possible benchmark evolution
This benchmark is expected to be refined by:

* Providing another scheme for more accurate startup time measurement;
* Adding more representative kernel functions in OpenCV;
* Adding multi-thread and SIMD mode.

## Benchmark category
I think this benchmark should be categorized as “kernel”.

## License

### License for perf.js and opencv-kernel.html
```
Copyright 2020 Intel Corporation

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

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

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 But before running this script, please ensure the Emscripten is successfully installed and can be located with the environment variables.

## How to run
This workload could run in three modes with input images of different sizes: small (640\*480), medium (1280\*720) and large (1920\*1080). And it supports Node.js, V8 shell and browsers.

Node.js:
```
node perf.js [mode]
```
V8 shell:
```
d8 perf.js [-- mode]
```
Browsers with the workload deployed at localhost:8000:
```
chrome http://localhost:8000/opencv-kernel.html[?mode]
```
If *mode* is not specified, the workload runs in small mode by default.

## Expected output
Moreover, this workload prints the startup time ("Prepare time"), total execution time each workload takes ("elapsed time") and average execution time ("average time") in milliseconds (ms), together with the standard deviation of execution time of 1000 rounds. The output matrices of the functions will not be displayed due to their huge sizes, instead, the benchmark checked the sha256 checksums of the results of last iterations.

An example of the output shows:
```
opencv.js loaded
Prepare time: 1379.532
=== cvtColor ===
elapsed time:<PHONE_NUMBER>000002
average time: 0.3636110000000008
stddev: 0.027607022276954076 (7.59%)
=== threshold ===
elapsed time:<PHONE_NUMBER>9999986
average time: 0.19137500000000068
stddev: 0.017555750482386855 (9.17%)
=== integral ===
elapsed time: 1069.445
average time: 0.6642880000000128
stddev: 0.04055493873748415 (6.11%)
```
And here lists the performance data of d8 (8.5.58) with only TurboFan, data on Node.js and browsers should be close to it.
<table>
    <tr>
        <td>mode</td>
        <td>Prepare time</td>
        <td>Kernel</td>
        <td>elapsed time</td>
        <td>average time</td>
        <td>stddev</td>
    </tr>
    <tr>
        <td rowspan="3">small</td>
        <td rowspan="3">1379.532</td>
        <td>cvtColor</td>
        <td>399.521</td>
        <td>0.364</td>
        <td>0.027 (7.59%)</td>
    </tr>
    <tr>
        <td>threshold</td>
        <td>228.275</td>
        <td>0.191</td>
        <td>0.018 (9.17%)</td>
    </tr>
    <tr>
        <td>integral</td>
        <td>1069.445</td>
        <td>0.664</td>
        <td>0.041 (6.11%)</td>
    </tr>
    <tr>
        <td rowspan="3">medium</td>
        <td rowspan="3">1397.564</td>
        <td>cvtColor</td>
        <td>1149.412</td>
        <td>1.080</td>
        <td>0.033 (3.08%)</td>
    </tr>
    <tr>
        <td>threshold</td>
        <td>639.416</td>
        <td>0.571</td>
        <td>0.014 (2.40%)</td>
    </tr>
    <tr>
        <td>integral</td>
        <td>2805.676</td>
        <td>1.958</td>
        <td>0.090 (4.59%)</td>
    </tr>
    <tr>
        <td rowspan="3">large</td>
        <td rowspan="3">1381.105</td>
        <td>cvtColor</td>
        <td>2552.249</td>
        <td>2.419</td>
        <td>0.115 (4.75%)</td>
    </tr>
    <tr>
        <td>threshold</td>
        <td>1380.083</td>
        <td>1.249</td>
        <td>0.039 (3.10%)</td>
    </tr>
    <tr>
        <td>integral</td>
        <td>6183.895</td>
        <td>4.357</td>
        <td>0.172 (3.96%)</td>
    </tr>
</table>

## Profile report
We profiled the medium workload on d8 (8.5.58, only TurboFan) with Linux Perf tool:

```
perf record -k mono d8 --perf-prof --no-wasm-tier-up --no-liftoff perf.js -- medium
perf inject -j -i perf.data -o perf.data.jitted
perf report -i perf.data.jitted
```

And here is a snapshot of the profile report:

```
Samples: 56K of event 'cycles', Event count (approx.):<PHONE_NUMBER>8
Overhead  Command          Shared Object          Symbol
  15.90%  d8               jitted-30366-1605.so   [.] Function:wasm-function[3916]-3916-turbofan
   8.70%  d8               jitted-30366-8402.so   [.] Function:wasm-function[2905]-2905-turbofan
   4.54%  d8               jitted-30366-1739.so   [.] Function:wasm-function[3928]-3928-turbofan
   2.64%  d8               jitted-30366-12697.so  [.] LazyCompile:*hash ./sha256.js:38
   2.25%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::LinearScanAllocator::ForwardStateTo
   2.13%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::LinearScanAllocator::FindFreeRegistersForRange
   1.88%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::LiveRangeConnector::ResolveControlFlow
   1.33%  d8               d8                     [.] v8::internal::Scavenger::EvacuateShortcutCandidate<v8::internal::CompressedHeapObjectSlot>
   1.25%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::LinearScanAllocator::TryAllocatePreferredReg
   1.20%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::Scheduler::PrepareUses
   1.17%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::GraphReducer::ReduceTop
   1.08%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::GraphTrimmer::TrimGraph
   1.08%  d8               jitted-30366-628.so    [.] Builtin:TypedArrayPrototypeJoin
   0.97%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::LinearScanAllocator::PickRegisterThatIsAvailableLongest
   0.94%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::ScheduleEarlyNodeVisitor::VisitNode
   0.92%  V8 DefaultWorke  d8                     [.] std::__1::__tree<v8::internal::compiler::LiveRange*, v8::internal::compiler::LinearScanAllocator::UnhandledLiveRangeOrdering, v8::internal::ZoneAllocator<v8::internal::compiler::LiveRange*> >::__emplace_multi<v8::internal::compi
   0.89%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::LinearScanAllocator::TryAllocateFreeReg
   0.85%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::LiveRangeBuilder::ProcessInstructions
   0.84%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::ScheduleLateNodeVisitor::SplitNode
   0.73%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::ScheduleLateNodeVisitor::VisitNode
   0.70%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::LinearScanAllocator::UpdateDeferredFixedRanges(v8::internal::compiler::RegisterAllocationData::SpillMode, v8::internal::compiler::InstructionBlock*)::$_3::operator()(v8::internal::compiler::LiveRange*) co
   0.69%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::OperandAssigner::CommitAssignment
   0.65%  d8               d8                     [.] v8::internal::BodyDescriptorBase::IteratePointers<v8::internal::IterateAndScavengePromotedObjectsVisitor>
   0.63%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::LinearScanAllocator::AllocateRegisters
   0.61%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::LinearScanAllocator::AssignRegisterOnReload
   0.59%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::BasicBlock::GetCommonDominator
   0.56%  V8 DefaultWorke  d8                     [.] std::__1::__tree_balance_after_insert<std::__1::__tree_node_base<void*>*>
   0.54%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::Node::New
   0.53%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::InstructionSelector::VisitBlock
   0.53%  d8               jitted-30366-672.so    [.] Builtin:StringPrototypeCharCodeAt
   0.52%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::Scheduler::DecrementUnscheduledUseCount
   0.51%  d8               d8                     [.] v8::internal::String::WriteToFlat<unsigned char>
   0.50%  V8 DefaultWorke  d8                     [.] v8::internal::wasm::WasmFullDecoder<(v8::internal::wasm::Decoder::ValidateFlag)1, v8::internal::wasm::(anonymous namespace)::WasmGraphBuildingInterface>::DecodeFunctionBody
   0.48%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::OperandAssigner::AssignSpillSlots
   0.45%  d8               jitted-30366-1599.so   [.] LazyCompile:*decodeBase64 ./opencv.js:31
   0.45%  V8 DefaultWorke  d8                     [.] v8::internal::TickCounter::DoTick
   0.44%  d8               d8                     [.] v8::internal::MarkCompactCollector::ProcessMarkingWorklist<(v8::internal::MarkCompactCollector::MarkingWorklistProcessingMode)0>
   0.44%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::ScheduleEarlyNodeVisitor::PropagateMinimumPositionToNode
   0.42%  V8 DefaultWorke  d8                     [.] std::__1::__tree_remove<std::__1::__tree_node_base<void*>*>
   0.40%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::LinearScanAllocator::AllocateBlockedReg
   0.40%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::MoveOptimizer::MigrateMoves
   0.39%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::LiveRangeConnector::ConnectRanges
   0.39%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::TopLevelLiveRange::AddUseInterval
   0.39%  d8               d8                     [.] v8::internal::Uri::Encode
   0.38%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::ValueNumberingReducer::Reduce
   0.38%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::InstructionSelector::SelectInstructions
   0.38%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::LinearScanAllocator::SetLiveRangeAssignedRegister
   0.36%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::ScheduleLateNodeVisitor::ProcessQueue
   0.36%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::RegisterAllocationData::GetOrCreateLiveRangeFor
   0.35%  d8               jitted-30366-59.so     [.] Builtin:StringIndexOf
   0.33%  d8               d8                     [.] v8::internal::Scavenger::Process
   0.32%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::LinearScanAllocator::AllocateRegisters()::$_4::operator()
   0.31%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::InstructionSequence::GetInstructionBlock
   0.31%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::LiveRangeBuilder::AddInitialIntervals
   0.31%  d8               d8                     [.] v8::internal::MarkingVisitorBase<v8::internal::MainMarkingVisitor<v8::internal::MajorMarkingState>, v8::internal::MajorMarkingState>::ProcessStrongHeapObject<v8::internal::CompressedHeapObjectSlot>
   0.31%  d8               jitted-30366-12698.so  [.] LazyCompile:*hash ./sha256.js:38
   0.31%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::LiveRangeBuilder::ComputeLiveOut
   0.30%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::InstructionSequence::GetSourcePosition
   0.30%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::Scheduler::UpdatePlacement
   0.30%  d8               d8                     [.] v8::internal::Worklist<std::__1::pair<v8::internal::HeapObject, int>, 256>::Pop
   0.29%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::ConstraintBuilder::MeetConstraintsBefore
   0.29%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::Schedule::AddNode
   0.29%  V8 DefaultWorke  libc-2.27.so           [.] _int_malloc
   0.28%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::ScheduleLateNodeVisitor::GetBlockForUse
   0.28%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::ScheduleLateNodeVisitor::ScheduleNode
   0.28%  d8               d8                     [.] v8::internal::Scavenger::ScavengeObject<v8::internal::CompressedHeapObjectSlot>
   0.27%  V8 DefaultWorke  d8                     [.] v8::internal::compiler::LiveRangeBuilder::Use
```
It can be observed that the top 3 functions are WebAssembly functions, which account for around 29.14% of the total CPU time.

## Known issues

It is observed on d8 that when tiers are not specified, the first testee (cvtColor) suffers from tier switching (Liftoff to Turbofan), while other functions runs on top tier only. This may lead to incomparable results. Currently, we'd like to recommend running this workload with only one tier enabled.

repository: WebAssembly/benchmarks

repo_name: WebAssembly/benchmarks


text:
---
categories: archive
---

- [Algorithms](http://jeffe.cs.illinois.edu/teaching/algorithms/ "http://jeffe.cs.illinois.edu/teaching/algorithms/")

- [This year in JavaScript: 2018 in review and npm’s predictions for 2019](https://blog.npmjs.org/post/180868064080/this-year-in-javascript-2018-in-review-and-npms "https://blog.npmjs.org/post/180868064080/this-year-in-javascript-2018-in-review-and-npms ") (12 min)
- [How and Why Reddit Uses Envoy Proxy](https://redditblog.com/2018/12/18/envoy-proxy-at-reddit/ "https://redditblog.com/2018/12/18/envoy-proxy-at-reddit/") (13 min)

- [What I learned at work this year](https://www.gatesnotes.com/About-Bill-Gates/Year-in-Review-2018 "https://www.gatesnotes.com/About-Bill-Gates/Year-in-Review-2018"), by Bill Gates (15 min)
- It’s a good time to [learn CSS Grid](http://cssgridgarden.com/ "http://cssgridgarden.com/") (game)


text:
# Tracking Configuration History

The ETL service, `ovirt-engine-dwhd`, tracks three types of changes:

* A new entity is added to the *engine* database - the ETL Service replicates the change to the *ovirt_engine_history* database as a new entry.

* An existing entity is updated - the ETL Service replicates the change to the *ovirt_engine_history* database as a new entry.

* An entity is removed from the *engine* database - A new entry in the *ovirt_engine_history* database flags the corresponding entity as removed. Removed entities are only flagged as removed.

The configuration tables in the *ovirt_engine_history* database differ from the corresponding tables in the *engine* database in several ways. The most apparent difference is they contain fewer **configuration** columns. This is because certain configuration items are less interesting to report than others and are not kept due to database size considerations. Also, columns from a few tables in the *engine* database appear in a single table in *ovirt_engine_history* and have different column names to make viewing data more convenient and comprehensible. All configuration tables contain:

* A `history_id` to indicate the configuration version of the entity;

* A `create_date` field to indicate when the entity was added to the system;

* An `update_date` field to indicate when the entity was changed; and

* A `delete_date` field to indicate the date the entity was removed from the system.

**Prev:** [oVirt History Database](../oVirt_history_database) <br>
**Next:** [Recording Statistical History](../Recording_statistical_history)

repository: leongold/ovirt-site

gha_license_id: NOASSERTION

repo_name: leongold/ovirt-site


text:
# S&P500 predict

### daily stock [Up/Down] predict by Machine Learning

* data source
  * America stocks (S&P500 component)
    * symbols: http://data.okfn.org/data/core/s-and-p-500-companies#data
    * values: yahoo finance
  * Japan stocks (Nikkei225 component)
    * symbols: http://swing-trade.net/nk225itiran
    * values: yahoo finance
  * Foreign Exchange(experimental)
    * values: oanda
* analysis method
  * linear regression(for compare)
  * feed forward network
* usage example
  * please see jupyter notebooks
    * [linear regression](https://github.com/sablet/algo_trade/blob/master/notebooks/inference.ipynb)
    * [data-describe](https://github.com/sablet/algo_trade/blob/master/notebooks/data-describe-and-learning-model.ipynb)

gha_language: Jupyter Notebook


text:
---
type: rule
archivedreason: Deprecated
title: Do you add the necessary code so you can always sync the web.config file?
guid: b497a0ee-eccc-4817-9033-a0338bee0542
uri: do-you-add-the-necessary-code-so-you-can-always-sync-the-web-config-file
created: 2009-04-28T02:05:28.0000000Z
authors:
- title: Adam Cogan
  url: https://ssw.com.au/people/adam-cogan
- title: Ryan Tee
  url: https://ssw.com.au/people/ryan-tee
  noimage: true
related: []
redirects: []

---

The Web.config file should be your main source where you store your application settings. These change, depending on which system you are working on, e.g. your local machine or the website. That's why you have to keep two versions of the Web.config file, one for your local machine and one for the website.
 That's annoying, not really efficient and often the cause of problems.

<!--endintro-->

In the following extract of a sample Web.config file you can see the problem. The local machine "HIPPO" has, of course, another WebServiceURL than the Webserver "SEAL". So you have to keep two versions of the Web.config file, one when working on "HIPPO" and one when working on "SEAL".

```xml
<add key="SEAL_WebServiceURL"
    value="http://host.something.com:80/SomeDirectory/Filename.asmx"/>
<add key="HIPPO_WebServiceURL"
    value="http://name:80/SomeDirectory/Filename.asmx"/>
```
**Figure: Sample Web.config file**

There is a better solution:

```vb
Public Shared Function GetWebConfigString(ByVal StringName As String) As String
Dim strReturn As String = ""
Dim strComputerName As String = System.Net.Dns.GetHostName
Try
strReturn = ConfigurationSettings.AppSettings( strComputerName.ToUpper _
+ "_"+ StringName)
Catch
strReturn = ConfigurationSettings.AppSettings(StringName)
End Try
Return strReturn
End Function
```
**Figure: Sample Get WebConfigString Class**

This class simply adds the name of the Computer on which it is running on to the WebConfigString. In the former example, this would be "HIPPO\_" or "SEAL\_".

Instead of using the WebConfigString directly you can now transform it using this function. With the help of this code, you always get the right value for the WebConfigString, no matter on which machine the application runs and you don't have to care about synchronizing the Web.config file any more.

gha_language: TSQL


text:
# ServiceAPI Java file download

This sample demonstrates using the generated client classes to interact with the ServiceAPI. See the [console app sample](../MyTestConsole) for more details on connecting to the ServiceAPI via Java.

# Important - Version support

The techniques used in this sample on work in ServiceAPI 9.0 and later.

# Download a file

The metadata generated for the ServiceAPI is useful for updating and getting metadata but downloading an electronic file requires more code. This sample creates a ULR connection using the JsonServiceClient and then some [borrowed](https://www.codejava.net/java-se/networking/use-httpurlconnection-to-download-file-from-an-http-url) code to do the actual download.

repository: rodneykee/Community

repo_name: rodneykee/Community


text:
---
order: 11
path: "/framework-of-specific-knowledge/"
title: "Framework of specific knowledge"
subtitle: "Arm yourself with specific knowledge and leverage."
intro: ""
---

Anything that can be trained, is replaceable. If robots can be trained to do it, you'll be extremely replaceable and earn a low wage.

Specific knowledge is something you can't be trained for. It can't be mass-produced or mass-trained as well.

People believe anything can be taught in school. But that's not true. The most specific knowledge comes from having a natural ability or curiosity in something. Or you're in a complex environment and are able to create judgment in a specific domain.

You can learn investing from reading books, but real-life investing has too many variables. You will need to gain a long time of actual experience to be able to good at it.

Everything can be learned, but not everything can be taught.

# Specific knowledge is found by pursuing your curiosity

Pursue your innate talents, curiosity, and passions.

You find specific knowledge in your passion. You have to be a 100% into it, otherwise, someone else will outperform you.  It doesn't matter how smart you are or how many hours you put in.

It could be something that you were praised for in your youth. Often parents will know exactly what it is. Naval wanted to be a scientist when he was young. But without realizing he was more into doing business. His mom called this out when he was very young. She had observed that Naval had a business-curious mind.

Nowadays Naval combines business with his passion for science and gained specific knowledge.

# Specific Knowledge Is Highly Creative or Technical

Specific knowledge tends to be creative or technical. It’s on the bleeding edge of technology, art, and communication.

## Specific knowledge can be taught through apprenticeships

The best careers are the apprenticeship- or self-taught careers. Society hasn't figured out yet how to train or automate it. A classic example is Warren Buffet who worked for free for Benjamin Graham. He learned from someone who had specific knowledge himself.

Another great example is Scott Adams. He made accurate predictions through persuasive arguments and videos and was able to brand Dilbert cartoons and mastered Periscope. His brand is unique and he creates wealth using these tools. He has unique knowledge that can't be easily taught or automated. He puts his name out there (see [accountability](/accountability/) and creates enormous leverage this way.

[Scott Adams advises](https://www.scottadamssays.com/2016/01/21/trumps-talent-stack-systems-versus-goals/) to pick a stack of skills, learn them good enough and combined you'll be able to gain specific knowledge. You don't have to be the best in each topic, but just good enough.

# Natural abilities

But you can't be too deliberate about learning specific knowledge. It has to be a natural obsession. If you're too deliberate, you're probably too goal-oriented on money and will not pick the right thing. You need to be a natural at it to obsess about it and to go deep enough and learn the specifics.

# Learn to sell and learn to build.

A great example of 2 skills that can be leveraged massively is building and selling. Learn what people want to buy, how to sell and how to scale. Be able to build it yourself and you have the ultimate combination.

building = programmer, engineer

sales = marketing, communication, recruiting, raising money

Silicon valley loves a team that builds and sells. Popular examples are:

- Steve Jobs and Steve Wozniak (Apple)
- Gates and Allen (Microsoft)
- Larry and Sergey (Google)

Elon Musk is an example of someone who can do both.

Building is much harder to learn than marketing. Bill Gates famously paraphrases this as, “*I’d rather teach an engineer marketing, than a marketer engineering.*”

You will need a large amount of time to learn the complexities of building. Then learn to sell. It is something you can learn later in life. You need to be able to sell to understand how to scale and to understand what a market wants.

url: https://raw.githubusercontent.com/flowen/principlesofwealth/1b2b62d3bdf5f6184a01b02a9a73da9be06dfb14/src/data/chapters/11. framework of specific knowledge.md

repository: flowen/principlesofwealth

filename: 11. framework of specific knowledge.md

gha_language: SCSS

repo_name: flowen/principlesofwealth


text:
## Car Price Steps

### [Car Price using Automated ML UI](https://github.com/DataSnowman/analytics-accelerator/blob/main/usecases/carprice/steps/carpriceautomlui.md)

Use these steps to build a car price model using the Azure ML Automated ML user interface

![openautoml](https://raw.githubusercontent.com/DataSnowman/analytics-accelerator/main/images/openautoml.png)

### [Consuming the model using Power BI AI insights](https://github.com/DataSnowman/analytics-accelerator/blob/main/usecases/carprice/steps/carpricepowerbidesktop.md)

Use these steps to consume the car price model you built using Power BI AI insights

![pbiaiinsights](https://raw.githubusercontent.com/DataSnowman/analytics-accelerator/main/images/pbiaiinsights.png)

repository: nixent/analytics-accelerator

repo_name: nixent/analytics-accelerator


text:
# VAR_ANNOT
##### A simple VCF annotation tool.

## What does it do?

Parses a VCF file and outputs an annotated VCF file with the following
information for each variant:

- 'TYPE' (The type of allele, either snp, mnp, ins, del, or complex)
- 'DP' (Depth of sequence coverage at the site of variation)
- 'AO' (Alternate allele observation count)
- 'AF' (Estimated allele frequency in the range (0,1))
- '#CHROM' (Chromosome that the variant is on)
- 'POS' (Position of the variant on the chromosome)
- 'REF' (Allele of the reference genome)
- 'ALT' (Alternative allele detected by the variant caller)
- 'ALLELE_FREQUENCY(ExAC)' (Allele frequency as reported by the ExAC Browser
API (http://exac.hms.harvard.edu/))

## Setup

```
$git clone https://github.com/brettvanderwerff/var_annot
$cd var_annot
$pip install -r requirements.txt
```

## Usage Case

var_annot has a simple command line interface and accepts two command
line arguments

- path to the VCF file to be annotated
- the row number of the VCF header (usually the first row following the
 meta-information rows in the VCF file)

From the top level folder:

```
$python3 var_annot.py ./example_data/Challenge_data.vcf 142
```

Processing takes a few minutes.
When complete an annotated VCF should appear in the `output` folder

## Requirements

##### Python Version:

- Tested on 3.6.8

##### Python Packages:

- numpy==1.16.2
- pandas==0.24.2
- requests==2.21.0

##### OS:

- Tested on Ubuntu 18.04

## Future Directions:

I did not get the opportunity to implement all of the requested features.
I do have some thoughts on how to complete this project and improve
the existing functionality.

1. It has a fragile CLI right now, but could be improved with one of
the nice CLI packages like 'argparse'.

2. The `expand_df` function, which turns DataFrame columns that contain
delimited key value pairs into their own DataFrames is a bottleneck. It could be
parallelized easily, but there are also a lot of loops in this function, which may need to be rethought.

3. Part of the challenge was to annotate:

     "Type of variation (Substitution,
    Insertion, Silent, Intergenic, etc.) If there are multiple
    possibilities, annotate with the most deleterious possibility."

    I just did not get this far, but my logic was to have a DataFrame with
    multiple rows dedicated to a different one of these possibilities. I
    could then drop duplicates based upon a function that ranks the
    different deleterious possibilities. I would keep only the most deleterious after dropping duplicates.
    I was headed in this direction, that is why in some cases the final annotated VCF has
    multiple rows representing the same chromosome position.

4. The functions that call to the ExAC server are a little fragile.
It would be better if they handled exceptions from a
non-responsive server and gave informative readout to the user.

5. Of course having a "gold standard" VCF file and building tests around it would be good.

gha_language: Python


text:
# Classes And Data Structures

## Commit

This class stores the data associated with each commit made.

**Fields:** Log message, Time of creation, A mapping of file names to blobs associated, Parent, Second parent

## Blob

This class encapsulates a file.

**Fields:** Name of file encapsulated, File encapsulated.

## Tag

A pointer to a certain commit, with a certain name.

**Fields:** name, commit ID associated, isActive.

## Stage

An object representing the staging area of a repository.

**Fields:** A mapping of file names to associated blobs. A list of all files staged for removal.

---

# Algorithms

## Main

- `initialize()`: Get .gitlet repo, with subdirs commits, tags, staging, files
- `handleAdd()`: Check if file exists in working directory, and abort if it doesn't. Send to
(new Stage( )).addFile(<file name>).
- `handleCommit()`: Checks for edge cases in spec. Else, commit ( ).
- `handleRemoval()`: Handles failures. stageRemoval(<file name>)

## Commit

- `commit()`: create an empty "initial commit" and save that to .gitlet/commits
- `commit(message)`: makeCommit( )
- `makeCommit()`: Deserialise most recent commit. Make the parent of this commit and this mapping the parent's mapping. Deserialise the staging object. Go through its mapping and update whichever name is necessary in current object. If the file didn't exist in this's mapping, add it. For every file in the stage object's remove list, remove it from the commit's mapping. For every file in the stage object mapping, move the file .gitlet/staging to .gitlet/files. clearStage(). Serialize this object and save it in .gitlet/commits. updateTag().
- `getCurrCommit()`: Look in active.txt in .gitlet/tags to get <name> –– get the commit ID mentioned in <name>.txt in .gitlet/tags.  Deserialize and return Commit object.
- `displayLog()`: getCurrCommit(). Display currCommit, with additional merge statement when both parents ≠ null. Recursive with curr's parent, til parent is null.
- `displayGlobalLog()`: getCurrCommit(). Display currCommit, with additional merge statement when both parents ≠ null. Recursive with curr's parents, til parent is null.
- `find()`: Use the process of global-log to go through the commits. For each commit, check if the message matches –– if it does, display the ID, and turn a local variable foundCommit to true. If foundCommit is false at the end of the recursion, throw up error message.
- `checkout(<commit id>, <file name>)`: If no such commit ID exists, abort. If the file does not exist, abort.  Overwrite the file in the working directory with this file. Create a new stage object. If the previous version of the given file was staged, remove it from the stage object's mapping ("unstage"). Update `stage.txt` .
- `checkout(<branch name>)`: Check if stageEmpty() –– if not, abort. Deserialize `branchlist.txt` and get a list of all the tags available. If the <branch name> is not in the tags, abort. Get current branchname from `active.txt`. If <branch name> is active branch, then abort. Else, make `active.txt`  the given branch

## Blob

- `equals()`

## Stage

- `addFile(<file name>)`: getCurrCommit( ). getCurrStage( ). UpdateMap(Curr Stage's Map). Search for <file name> is curr commit's blobmap. If not found or if found and the blobs are not equal, create a blob of <file name>, and stageAddition(<file name>, <blob>). If the blobs are equal, unstage(<file name>). Finally, updateStage().
- `updateMap(<Map>)`: Update this's map to be <Map>.
- `stageAddition(<file name>, <blob>)`: Add <file name> to map if it doesn't exist, otherwise overwrite with <blob>. StageFile(<file name>).
- `stageRemoval(<file name>)`: getCurrStage( ). updateMap(<curr map>). If the given file exists in the stage object's mapping, remove it and remove its corresponding file from .gitlet/staging. Save a serialized version of current stage object in `stage.txt`. Else, getCurrCommit( ). If the file exists in this commit, then add the file name to the list of remove files in the stage object. Serialize this object as `stage.txt` and save it in .gitlet/staging. If neither of the above are true, abort with message.
- `stageFile(<file name>)`: Add file attached to <file name> to .gitlet/staging.
- `unstage(<file name>)`: If <file name> exists in map, remove it from map. If <file name> exists in removal list, remove it from list. Else, no nothing.
- `static getCurrStage()`: If `stage.txt` exists in .gitlet/staging, deserialize and return. Else, return null.
- `updateStage()`: Rewrite/write `stage.txt` to be this object, serialized.
- `stageEmpty()`: Returns true if `stage.txt` does not exist in .gitlet/staging else false.
- `clear()`: Deletes `stage.txt`

## Tag

- `tag([commit id], active)`: create the initial tag with the name "master". If active, makeActive. Add to branchlist listBranch. Save in .gitlet/tags.
- `makeActive()`: Create a file `active.txt` in .gitlet/tags if it doesn't exist, otherwise update it to save the this.name.
- `listBranch()`: Add this tag's name to `branchlist.txt` in .gitlet/tags.
- `updateTag(<commit id>)`: Update current tag.
- `status()`: Go through `branchlist.txt` and display all branches as per branches. If branch.isActive, display with asterisk. Deserialize the object in `stage.txt`, and go through it's mapping keys. Display them as the staged files. Display its remove list as removed files. Display Mods not staged for commit and untracked files headers.

---

# Persistence

- `index.txt`: The staging area.
- `objects`: All the serialized objects, including blobs and commits, as *Sha1Code*.txt.
- `head.txt:` Saves the name of the currently active branch.
- `branches`: Directory that contains files as *branchname*.txt, with each file containing the SHA 1 code to a commit.

---

repository: somaniarushi/gitlet

repo_name: somaniarushi/gitlet


text:
# Hot Reloading

This is a **experimental** prototype of Hot Reload for controllerbus.

Features:

 - Automatically codegen and compile overlay modules for a target
 - Load + resolve controllerbus controllers from plugins
 - Full support for Go modules and module replacements
 - Manifest of all currently loaded plugins
 - Detect Go module code changes and hot-reload

Cavets:

 - Go plugin system cannot fully unload memory, making a mem leak.
 - Plugins only work on Linux.
 - Fails if any of the packages shared w/ host process are changed.
 - All builds must use the "-trimpath" flag.

These are acceptable for development environments. Memory leak issue could be
addressed with ControllerBus IPC using cross-process controllers.

Reference: https://github.com/golang/go/issues/27751

## Known Bugs

When a plugin is compiled, the "main" package is actually compiled to a module
named "plugin/unnamed-hashstrhere" with a hash of the main file contents. This
package is reloaded correctly because it has a unique name (unique ID).

However, this doesn't accomplish what we want. I actually want to re-load the
package named "github.com/aperturerobotics/controllerbus/example/boilerplate".
Since this package is already loaded, Go does not re-load it from the plugin.

This code already will automatically insert entropy into the main package
contents to produce a unique plugin package ID. But this isn't enough, we need
to clobber the old code in the module tables as well.

Loading plugins works great. Re-loading them: not quite yet.

## Codegen Output Example

Example generated code:

```go
//+build controllerbus_hot_plugin

package main

import (
	"github.com/aperturerobotics/controllerbus/bus"
	"github.com/aperturerobotics/controllerbus/controller"
	boilerplate_controller "github.com/aperturerobotics/controllerbus/example/boilerplate/controller"
	"github.com/aperturerobotics/controllerbus/hot/plugin"
)
// BinaryID is the binary identifier.
const BinaryID = "example-binary"
// BinaryVersion is the binary version string.
const BinaryVersion = "0.0.0"
// BinaryFactories are the factories included in the binary.
var BinaryFactories = func(b bus.Bus) []controller.Factory {
	return []controller.Factory{boilerplate_controller.NewFactory(b)}
}
// Plugin is the top-level static plugin container.
type Plugin = hot_plugin.StaticPlugin
// NewPlugin constructs the static container plugin.
func NewPlugin() *Plugin {
	return hot_plugin.NewStaticPlugin(BinaryID, BinaryVersion, BinaryFactories)
}
// ControllerBusHotPlugin is the variable read by the plugin loader.
var ControllerBusHotPlugin hot_plugin.HotPlugin = NewPlugin()
// _ is a type assertion
var _ hot_plugin.HotPlugin = ((*Plugin)(nil))
```

repository: AnakinSong/controllerbus

repo_name: AnakinSong/controllerbus


text:
# Final Countdown TNG

This is a starter application to get you going on your final project.

## Running

Run this using [sbt](http://www.scala-sbt.org/).

```
sbt run
```

And then go to http://localhost:9000 to see the running web application.

## Controllers

There is a controller already in place to make sure this mostly empty project works.

- TestController.java:

repository: ManBearSquirrel/FinalCountdownTNG

repo_name: ManBearSquirrel/FinalCountdownTNG


text:
rexpro-python is now being maintained by platinummonkey, please direct issues and pull requests to this repo: https://github.com/platinummonkey/rexpro-python

rexpro
======

rexpro-python is an experimental rexpro socket interface for python

this library relies on recent changes to the rexster rexpro protocol, so you'll need to clone and build the rexster master branch if you want to use

## Installation
```
pip install rexpro
```

## Basic Usage

```python
from rexpro import RexProConnection

#create a connection
conn = RexProConnection('localhost', 8184, 'emptygraph')

#create and return some elements
#execute takes a script, and optionally, parameter bindings
#for parameterized queries
elements = conn.execute(
    """
    def v1 = g.addVertex([prop:bound_param1])
    def v2 = g.addVertex([prop:bound_param2])
    def e = g.addEdge(v1, v2, 'connects', [prop:bound_param3])
    return [v1, v2, e]
    """,
    {'bound_param1':'b1', 'bound_param2':'b2', 'bound_param3':'b3'}
)

#the contents of elements will be:
({'_id': '0', '_properties': {'prop': 'b1'}, '_type': 'vertex'},
 {'_id': '1', '_properties': {'prop': 'b2'}, '_type': 'vertex'},
 {'_id': '2',
  '_inV': '1',
  '_label': 'connects',
  '_outV': '0',
  '_properties': {'prop': 'b3'},
  '_type': 'edge'})
```

## Transactional Graphs

if you're using this with a transactional graph you can do requests in the context of a transaction one of two ways

```python
#first, by explicitly opening and closing a transaction
conn.open_transaction()
conn.execute("//do some stuff")
conn.close_transaction()

#second, with a context manager
with conn.transaction():
    conn.execute("//do some other stuff")
```

## Query scoping & global variables

A RexPro connection is basically a connection to a gremlin REPL.
Queries executed with the RexProConnection's `execute` method are automatically wrapped in a closure before being executed
to avoid cluttering the global namespace with variables defined in previous queries. A globally available `g` graph object
is is automatically defined at the beginning of a RexPro session.

If you would like to define additional global variables, don't define variables with a def statement. For example:

```python
#number will become a global variable for this session
conn.execute("number = 5")

#another_number is only available for this query
conn.execute("def another_number = 6")
```

repository: gavinls/rexpro-python

repo_name: gavinls/rexpro-python


text:
# Kristy_Bot
An IRC bot with probably Rizon specific commands. Requires two external libraries which you can obtain from here;

Javax.mail-1-5-4

https://java.net/projects/javamail/pages/Home

Pircbot

http://www.jibble.org/pircbot.php

There is an external .properties file with sensitive data (passwords and such) that will be required to run the program. The bot has the following major functions and many smaller minor ones;

1. Ability to read Inboxes, detect titles, set flags as well as write emails.
2. A giveaway system that chooses a random non-admin user in the channel. Complete with a 30 minute timer to accept with the !accept command.
3. Modular adding of new commands. Thanks to XSpeedPL.
4. Parser for usernames and an internal ranking system (VOICE, HALF-OP, OP, ADMIN)


text:
# Intraoperative Motion Classification

This tutorial is adapted from [Point cloud classification with PointNet](https://keras.io/examples/vision/pointnet/) with TensorFlow and Keras.

Here, we use Intraoperative motion data from an ultrasound-guided prostate intervention, for a motion detection problem. The clinical background can be found in the [MPHY0030 SSM tutorial](https://weisslab.cs.ucl.ac.uk/YipengHu/mphy0030/-/tree/main/tutorials/statistical_motion_model/python).

First download the simulated motion data by running the script in the [mphy0043 conda env](../../docs/dev_tools.md):
```bash
conda activate mphy0043
python download_data.py
```
The run the motion classification script:
```bash
python motion_classification.py
```

<img src="../../docs/media/motion.jpg" alt="alt text"/>


text:
# Kitara

### Overview

Kitara is a simple cross-platform program written in Rust that can convert any MIDI guitar to a computer keyboard. I wrote this quickly on a Sunday afternoon, just for fun, so this program has only been tested on MacOs Catalina.

### Requirements

* Rust
* A MIDI-compatible guitar
* Ability to geek out

### Usage

After compiling with cargo, run the program as shown in its usage:

```
Usage: kitara <device-name> <path/to/config/csv>
```

where:
* `device-name` is the (approximate) name of the midi guitar device connected to your system
* `path/to/config/csv` is the path to `map.csv` (a default file is provided) that contains a custom
mapping between the fretboard and a computer keyboard

### Current mapping
I have included the following mapping which is essentially a form of QWERTY with
the left hand keys turned upside down. This allows easy playability with both hands by
tapping.

The MIDI channels are specified on the first column and they can map to your own
string midi channels. Note that each guitar string must play in a separate channel, a feature
that all guitar midi players have.

```
0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21	22
--------------------------------------------------------------------------------------------
6|	RI	DO	LE		ES			BA	BA	BA	BA	BA				6	7	8	9	0	-	=
5|		UP						b	v	c	x	z	SH			y	u	i	o	p	[	]
4|								g	f	d	s	a				h	j	k	l	;
3|								t	r	e	w	q				n	m	,	.	/	SH	SH
2|	TA							5	4	3	2	1	`
1|	TA							CT	AL	CM			SP	SP	SP	SP	SP	SP			EN	EN
```

#### Key Abbreviations

* RI = Right Arrow
* DO = Down Arrow
* LE = Left Arrow
* UP = Up Arrow
* BA = Backspace
* TA = TAB
* CT = CTRL
* AL = ALT (Mac Option key)
* CM = CMD (Mac only)
* SP = Spacebar
* SH = Shift
* ES = Escape
* EN = Enter/Return

### Todo

* Add unit tests
* Refactor/optimize
* Support for any midi fretted instrument (maybe)
* Make tuning configurable (maybe)

repository: georgetheka/kitara

repo_name: georgetheka/kitara


text:
# Features

## Server

* Install server version from downloads site: `xl-helper install server --version 4.5.0`
* Install latest successful SNAPSHOT from Jenkins: `xl-helper install server`
* Install from the local file: `xl-helper install server --dist /tmp/xl-deploy-4.5.0-server.zip`
* Install and copy all the stuff from old installation: `xl-helper install server --version 4.5.0 --upgrade-from-path ./xl-deploy-4.1.0-SNAPSHOT-server`
* Start the server after installation: `blablabla -start`

## Plugin

* Install plugin version and restart if was started `xl-helper install plugin wls --version 4.5.0`
* Update plugin version and restart if was started

## Cli

* Install CLI version from downloads site: `xl-helper install cli --version 4.5.0`

## Other
* Downloaded artifacts are cached (except snapshots)

# Usage

## Requirements
`pip install jenkinsapi`
`pip install nose`

## Configuration file
Needs to be placed at `~/.xl-helper`
See `conf/.xl-helper.example` as an example.

## Bash alias

It's much more convenient to use `xl-helper` with configured bash alias:

`alias xl-helper="~/xl/research-and-development/xl-helper/xl-help.py"`

# Development

## Desired features

* In-place upgrade of the server
* Installation of plugins snapshots
* Install-as-update for the plugins: install if plugin is missing, upgrade/downgrade if already present
* Plugin upgrade should fail if the plugin is not installed/or newer version is installed
* Handle more corner-cases and errors

## Bugs

* Installation from an archive "xl-deploy-5.0.0-SNAPSHOT-sat-server.zip" does not work
  ** If it is impossible to detect, then give a clear error and provide an option to specify version manually

## Unit tests

Adding feature = Writing test + writing code

Running tests: `nosetests -v`

Tests are also runnable from IntelliJ

## Releasing new version

[read here](release.md)

repository: eltonkevani/xld-install-helper

repo_name: eltonkevani/xld-install-helper


text:
# Tag Release

A tag is required to create GitHub artifacts and as a prerequisite for publishing.

## Before you begin

1. All required commits for the release should exist on the release branch. This includes functionality and documentation such as the `CHANGELOG.md`. All versions in code should have already been updated.

2. Make sure you are up to date on the release branch:

   ```
   git checkout release-VERSION_PREFIX
   git fetch origin
   git pull origin
   ```

3. Determine the [VERSION](concepts/version.md).

4. Follow the GitHub [instructions](https://docs.github.com/en/authentication/managing-commit-signature-verification) to set up GPG for signature verification.

5. Optional: Configure git to always sign on commit or tag.

```bash
git config --global commit.gpgSign true
git config --global tag.gpgSign true
```

If you are on macOS or linux and using an encrypted GPG key, `gpg-agent` or `gpg` may be unable
to prompt you for your private key passphrase. This will be denoted by an error
when creating a commit or tag. To circumvent the error, add the following into
your `~/.bash_profile`, `~/.bashrc` or `~/.zshrc`, depending on which shell you are using.

```
export GPG_TTY=$(tty)
```

## Steps

1. Tag the release:

    Example commands:

    ```
    git tag -s VERSION
    git push origin VERSION
    ```

2. After a tag has been pushed, GitHub Tasks will create release assets and open a release draft for every pushed tag.

    - This will take ~20-40 minutes.
    - You can monitor this by viewing the drone build on the commit for the release tag.

    If the Homebrew Formula fails to update, close the existing open PR and re-run the failed CI.

repository: grafana/agent

gha_language: Go

repo_name: grafana/agent


text:
Interacting with Whedon
========================

Whedon or `@whedon` on GitHub, is our editorial bot that interacts with authors, reviewers, and editors on JOSS reviews.

`@whedon` can do a bunch of different things. If you want to ask `@whedon` what it can do, simply type the following in a JOSS `review` or `pre-review` issue:

```text
@whedon commands
```

This will return an output something like this:

```text
# List all of Whedon's capabilities
@whedon commands

# Assign a GitHub user as the sole reviewer of this submission
@whedon assign @username as reviewer

# Add a GitHub user to the reviewers of this submission
@whedon add @username as reviewer

# Remove a GitHub user from the reviewers of this submission
@whedon remove @username as reviewer

# List of editor GitHub usernames
@whedon list editors

# List of reviewers together with programming language preferences and domain expertise
@whedon list reviewers

# Change editorial assignment
@whedon assign @username as editor

# Set the software archive DOI at the top of the issue e.g.
@whedon set 10.0000/zenodo.00000 as archive

# Open the review issue
@whedon start review

🚧 🚧 🚧 Experimental Whedon features 🚧 🚧 🚧

# Compile the paper
@whedon generate pdf
```

## Author commands

### Compiling papers

When a `pre-review` or `review` issue is opened, `@whedon` will try to compile the JOSS paper by looking for a `paper.md` file in the repository specified when the paper was submitted.

If it can't find the `paper.md` file it will say as much in the review issue. If it can't compile the paper (i.e. there's some kind of Pandoc error), it will try and report that error back in the thread too.

```eval_rst
.. note:: If you want to see what command ``@whedon`` is running when compiling the JOSS paper, take a look at the code `here <https://github.com/openjournals/whedon/blob/195e6d124d0fbd5346b87659e695325df9a18334/lib/whedon/processor.rb#L109-L132>`_.
```

Anyone can ask `@whedon` to compile the paper again (e.g. after a change has been made). To do this simply comment on the review thread as follows:

```text
@whedon generate pdf
```

### Finding reviewers

Sometimes submitting authors suggest people the think might be appropriate to review their submission. If you want the link to the current list of JOSS reviewers, type the following in the review thread:

```text
@whedon list reviewers
```

## Editorial commands

Most of `@whedon`'s functionality can only be used by the journal editors.

### Assigning an editor

Editors can either assign themselves or other editors as the editor of a submission as follows:

```text
@whedon assign @editorname as editor
```

### Adding and removing reviewers

Reviewers should be assigned by using the following commands:

```text
# Assign a GitHub user as the sole reviewer of this submission
@whedon assign @username as reviewer

# Add a GitHub user to the reviewers of this submission
@whedon add @username as reviewer

# Remove a GitHub user from the reviewers of this submission
@whedon remove @username as reviewer
```

```eval_rst
.. note:: The ``assign`` command clobbers all reviewer assignments. If you want to add an additional reviewer use the ``add`` command.
```

### Starting the review

Once the reviewer(s) and editor have been assigned in the `pre-review` issue, the editor starts the review with:

```text
@whedon start review
```

```eval_rst
.. important:: If a reviewer recants their commitment or is unresponsive, editors can remove them with the command ``@whedon remove @username as reviewer``. You can also add new reviewers in the ``REVIEW`` issue, but in this case, you need to manually add a review checklist for them by editing the issue body.
```

### Assigning the software archive

When a submission is accepted, we ask that the authors create an archive (on [Zenodo](https://zenodo.org/), [fig**share**](https://figshare.com/), or other) and post the archive DOI in the `REVIEW` issue. The editor should add the `accepted` label on the issue and ask `@whedon` to add the archive to the issue as follows:

```text
@whedon set <archive doi> as archive
```

gha_language: Ruby


text:
# History
It all started when we got a C64 at some point. I loved that thing and I especially loved typing on it. Just interacting with it.

    OK.
    > PLOP YOU COMPUTER!
    SYNTAX ERROR.
    >

The thing had a tape drive and a notebook with the indexes of where every program *would* be. If you're lucky. Turns out the program is never at `163` or `164` but almost certainly somewhere in between. This meant that if I wanted to run **A** you would:

1. Lookup the index of **A** in the hand written notebook of the previous owner.
2. Hope you'll find it quickly
3. Seek to the position on the tape.
4. Try to run it
5. Get an error
6. Seek forward a little bit and try again
7. Repeat until it runs

Eventually me and my dad got sick of it and for some reason we didn't bother to invest in a disk drive - I was eight at the time and my dad wasn't *that* much into the home computer market anyway so I don't blame him.

 It had trouble running games because well Hercules but there were some I could run.

I remember mostly playing around with Banner and WordPerfect 5.1 in those days. Learned that dumping every file in `C:\` is a bad idea (thanks previous owner) and some funky stuff you could do with `.bat` files. Eventually I ended up writing *menus* for family and friends in the form of `.bat` scripts because nobody really knew what to do when they ended up at the `C:\>` prompt.

A few years later we finally got a real computer of our own, a 386DX40 and I got some good use out of that thing. That was also when I encountered so called *demos* which the rest of this will mostly be about.

# Demos
What do I mean? A *demo* as considered here is a piece of software that is intended to show off the skills of one or more people. Those skills usually relate to programming, music and art (the three skills that are important to create games in particular).

Most demos are created by a group of people. Usually three of more where you have a programmer, an artist and a composer. It's not uncommon that some people can perform in multiple roles.

Some of these early crews have grown to big companies by now (DICE for example) and some of the names exist for more than 30 years now (Fairlight) but I don't think the original crew is still the same. A lot of them started out as so called *crackers* that made it their mission to find ways to bypass the digital security around video games at that time.

Here's a reasonably short example of a somewhat modern demo.

[Conspiracy Theory 64k](https://www.youtube.com/watch?v=ZfuierUvx1A)

**Assembly** is the biggest demo party (or at least the most legendary) and it's held in Helsinki each year. That's also why I'm going to visit that city later this year, after years of longing I'll finally be visiting.

# TODO
* Personal efforts
* General about demos and how progging, visuals and music fit together

repository: basp/notes

repo_name: basp/notes