text:
# Greenbow

A free mobile application visualizing carbon emissions of companies.

Retail consumers are encouraged to used this application to understand the environmental impact caused by companies selling a product, in order to look for alternatives. For instance, Tom wants to purchase a Coffee from the most environmently friend coffee shop in the local area.

## Download

Currently under development.

## Build

This is a Clojurescript application using Reframe and React Native.
Created with 're-natal init greenbow'

### Development mode on real Android device

One time operation to tell figwheel use external react native components
```
re-natal require react-native-autocomplete-input
```

From terminal 1: use figwheel to start the application
```
adb reverse tcp:8081 tcp:8081
adb reverse tcp:3449 tcp:3449
re-natal use-android-device real
re-natal use-figwheel
lein figwheel android
```

From terminal 2: start the react native console
```
react-native run-android
```

### Run tests
`lein test-cljs` Run Clojurescript tests

### Production build
`lein prod-build` Production build
`cd android && ./gradlew assembleRelease` Generate release APK
`react-native run-android --variant=release` Install release to device or emulator
`adb logcat -v threadtime <device id> > debug.log` Capture device log. Use `adb devices` to find device.

One time command used to generate private key to sign the APK:
`keytool -genkeypair -v -keystore greebow-apk.keystore -alias greenbow -keyalg RSA -keysize 2048 -validity 10000` Located under android/app.

### External React Native modules
- react-native-autocomplete-input 3.6.0
      An auto-complete textbox displaying a list with entries matching the entered text.

See npm-deps in project.clj to import the nodejs module.
See ui.cljs to import module as react class

### Appendix
```
#npm install --save react-native-autocomplete-input
#re-natal enable-auto-require
#npm install klaw-sync -g
#re-natal {traverseAll: true} require-all
```

repository: lucasgut/greenbow

repo_name: lucasgut/greenbow


text:
---
title: 'Ethylene Removal System'
permalink: /productivity-solutions-grant/solutionrepo/solution2003
---

## Ethylene Removal System

## Overview

**Description**

An equipment which eliminates ethylene gas in the air effectively. Ethylene that is released naturally can be continuously removed by the equipment. No amount of harmful substance (e.g. ozone) should be released as a result of removing the ethylene. Equipment is to be used in cold storage warehouses and production facilities for the purpose of extending the shelf life of fresh produce.

Cost of equipment capped at $37,500 per unit

## Solution Packages Option(s)

Equipment Name
Cost Cap
Mandatory Specifications

Ethylene Removal System
37500
Specifications:
- Removes ethylene from the environment, resulting in longer shelf life and reduced spoilage in produce.
- No harmful substance must be released into the environment E.g. Ozone
- Can be used in storage and production facilities.
- Installation and maintenance costs are not supported.

## Mode and Schedule of Payment

 - Direct Purchase

Interested companies can get a quotation from your selected vendor, before applying for the PSG through the Business Grant Portal (BGP).

license: MIT

repository: isomerpages/govtech-gobusiness

branch_name: refs/heads/staging

extension: md

gha_language: HTML

gha_license_id: NOASSERTION

license_type: permissive

repo_name: isomerpages/govtech-gobusiness


text:
# Active Query Builder Electron demo

##### To run the project:

1. Execute the `npm install` command,

2. Run the JavaScript demo project,

3. Execute the `npm start` command.

branch_name: refs/heads/master

gha_language: C#


text:
# Cladonia furcata var. hians Müll. Arg. VARIETY

#### Status
SYNONYM

#### According to
Index Fungorum

#### Published in
Flora, Jena 65: 295 (1882)

#### Original name
Cladonia furcata var. hians Müll. Arg.

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Ascomycota/Lecanoromycetes/Lecanorales/Cladoniaceae/Cladonia/Cladonia scabriuscula/ Syn. Cladonia furcata hians/README.md

repo_name: mdoering/backbone


text:
---
layout: post
title:  "C# Asynchronous Tcp Server"
date:   2012-09-01 20:02:05 +0300
tags: c-sharp tcp
redirect_from: /networking/c-asynchronous-tcp-server
image: /imgs/thumbnails/asynctcplistener.webp
---

This is the model of an **Asynchronous TCP server**, that can have multiple clients connected, each one on it's own **thread** - all of this is done using a relatively short and easy-to-remember code.

If you don't have basic knowledge of how a Tcp server works, it is highly recommended to read first: [how to make a simple tcp server](https://www.codingvision.net/networking/c-simple-tcp-server "C# simple tcp server").

## The code

As always, the code first and after, the comments:
* functions used for sending/receiving data are not included - you should know these, from the basic server stuff.

```csharp
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net;
using System.Net.Sockets;

using System.Threading;

namespace ServerTest
{
    class Program
    {

        static void Main(string[] args)
        {
            Program main = new Program();
            main.server_start();  //starting the server

            Console.ReadLine();
        }

        TcpListener server = new TcpListener(IPAddress.Any, 9999);

        private void server_start()
        {
            server.Start();
            accept_connection();  //accepts incoming connections
        }

        private void accept_connection()
        {
            server.BeginAcceptTcpClient(handle_connection, server);  //this is called asynchronously and will run in a different thread
        }

        private void handle_connection(IAsyncResult result)  //the parameter is a delegate, used to communicate between threads
        {
            accept_connection();  //once again, checking for any other incoming connections
            TcpClient client = server.EndAcceptTcpClient(result);  //creates the TcpClient

            NetworkStream ns = client.GetStream();

            /* here you can add the code to send/receive data */

        }

    }
}
```

## Comments

This is the server, containing almost anything required to work properly.

Now, to understand how it works, take a look at the methods below:

```csharp
        private void server_start()
        {
            ...
            accept_connection();
        }

        private void accept_connection()
        {
            server.BeginAcceptTcpClient(handle_connection, server);
        }

        private void handle_connection(IAsyncResult result)
        {
            accept_connection();
            TcpClient client = server.EndAcceptTcpClient(result);
            ...
        }

```

- first, the program calls the function `accept_connection()` - used to accept a client's connection to the server. This function will invoke through `BeginAcceptTcpClient` another function called `handle_connection()` which will run on a **different thread** chosen from the **threadpool** - so you don't have to manually create/release threads.

- when `handle_connection()` is called, it also receives an `IAsyncResult` argument - this argument maintains the connection between the 2 threads. This method will then call again `accept_connection()` - so the program will constantly change the threads.

- if the connection is closed, the thread used is released automatically and can later be used for a new client; however this threadpool is limited.

## In the end...

This is basically everything you _might_ need to know about the **asynchronous tcp servers** - without involving any unnecessary code. If there are any questions, feel free to leave a comment :)

extension: markdown

gha_language: CSS

gha_license_id: MIT


text:
# IntersightClient::MacpoolBlock

## Properties

| Name | Type | Description | Notes |
| ---- | ---- | ----------- | ----- |
| **class_id** | **String** | The fully-qualified name of the instantiated, concrete type. This property is used as a discriminator to identify the type of the payload when marshaling and unmarshaling data. | [default to 'macpool.Block'] |
| **object_type** | **String** | The fully-qualified name of the instantiated, concrete type. The value should be the same as the 'ClassId' property. | [default to 'macpool.Block'] |
| **from** | **String** | Starting address of the block must be in hexadecimal format xx:xx:xx:xx:xx:xx. To ensure uniqueness of MACs in the LAN fabric, you are strongly encouraged to use the following MAC prefix 00:25:B5:xx:xx:xx. | [optional] |
| **to** | **String** | Ending address of the block must be in hexadecimal format xx:xx:xx:xx:xx:xx. | [optional] |

## Example

```ruby
require 'intersight_client'

instance = IntersightClient::MacpoolBlock.new(
  class_id: null,
  object_type: null,
  from: null,
  to: null
)
```

repository: xlab-si/intersight-sdk-ruby

branch_name: refs/heads/main

gha_language: Ruby

repo_name: xlab-si/intersight-sdk-ruby


text:
# vmaxflow

Implementation of the [Push-Relabel Method][]
for the [Maximum Flow Problem][].

    Usage: java -jar vmaxflow.jar <filename> <outputfilename>

Given Graph *G = (V, A)* with capacity function *c(a) > 0* for all arc *a* in *A*.
The output is a maximum flow function *f* over *A* from a source vertex *s* to the sink vertex *t*.

Content of an example input file:

    # Node u, Node v, Capacity of arc uv
    0, 1, 15
    0, 3, 4
    1, 2, 12
    2, 3, 3
    2, 5, 7
    3, 4, 10
    4, 1, 5
    4, 5, 10

The node `u` in the first input line will be interpreted as the source vertex.
This is the node `0` in the example.
The node `v` in the last input line will be interpreted as the sink vertex.
This is the node `5` in the example.
All lines beginning with the character '#' will be interpreted as comment lines.

Content of output file:

    # Node u, Node v, Flow on arc uv, Capacity of arc uv
    0, 1, 10, 15
    0, 3, 4, 4
    1, 2, 10, 12
    2, 3, 3, 3
    2, 5, 7, 7
    3, 4, 7, 10
    4, 1, 0, 5
    4, 5, 7, 10

The value of the flow on an arc `uv` will be placed in the third column.
If no output file name specified, the default output file name will be used.

For an example of the code usage see the file `SimpleExample.java` in `example` package.

## Reference

Cherkassky, B. V., Goldberg,, A. V.: On Implementing the Push-Relabel Method for the Maximum Flow Problem.
Algorithmica 19, 390-410 (1997)

[Push-Relabel Method]: https://en.wikipedia.org/wiki/Push%E2%80%93relabel_maximum_flow_algorithm
[Maximum Flow Problem]: https://en.wikipedia.org/wiki/Maximum_flow_problem

repository: viqizevic/vmaxflow

repo_name: viqizevic/vmaxflow


text:
---
title: "getNextUntil.js"
date: 2018-01-24T12:16:26-05:00
draft: false
description: "Get all next siblings of an element until a test condition is met."
how: "https://gomakethings.com/how-to-get-all-siblings-of-an-element-until-a-selector-is-found-with-vanilla-js/"
demo: "https://codepen.io/cferdinandi/pen/LqEENq"
weight: 10
noIndex: false
---

```js
/*!
 * Get next siblings of an element until a test condition is met
 * (c) 2021 Chris Ferdinandi, MIT License, https://gomakethings.com
 * @param  {Node}     elem     The element
 * @param  {Function} callback The test condition
 * @return {Array}             The siblings
 */
function getNextUntil (elem, callback) {

	// Setup siblings array and get next sibling
	let siblings = [];
	let next = elem.nextElementSibling;
	let index = 0;

	// Loop through all siblings
	while (next) {

		// If the matching item is found, quit
		if (callback && typeof callback === 'function' && callback(next, index, elem)) break;

		// Otherwise, push to array
		siblings.push(next);

		// Get the next sibling
		index++;
		next = next.nextElementSibling;

	}

	return siblings;

}
```

repository: stockitories/vanilla-js-toolkit

repo_name: stockitories/vanilla-js-toolkit


text:
# Brocfile Transition

## Why

Broccoli historically assumed its brocfile was like a main file. Originally, we loaded the required config on-demand when the brocfile was invoked, unfortunately as the addon story evolved, we required this data before the brocfile was even invoked (or for tasks where no brocfile invocation was needed). This created a problem, and the quickest solution lead us to the current state of affairs, where we end up duplicating much internal state to satisfy both parts of the system.

This change occurred in an effort to unify both sides, rather then duplicating state, we can now pass that state in as an argument. Since the behavior of this file is a superset of a typical Brocfile, we opted to also change the name.

With this change, we are in a good position to fix more bugs, remove some much needed tech-debt, and continue to improve the internals without causing uneeded pain in userland.

Happy Hacking!

## How

Transitioning your Brocfile is fairly straight forward. Simply take the contents of your Brocfile and place it in the body of the function in the new `ember-cli-build.js` file.  Instead of using `module.exports` to return the tree simply have the function return the tree.  Ensure you pass the `defaults` to the EmberApp constructor along with any options you were passing to `EmberApp` in the Brocfile.  Internally these two objects will be merged from right to left.

Two steps:

1. Remove `Brocfile.js` and add contents into `ember-cli-build.js`
2. Pass `defaults` into the `EmberApp` constructor

## Before (Brocfile.js)

```
var EmberApp = require('ember-cli/lib/broccoli/ember-app');
var app = new EmberApp();
app.import("file1.js");
app.import("file2.js");
module.exports = app.toTree();
```

## After (ember-cli-build.js)
```
var EmberApp = require('ember-cli/lib/broccoli/ember-app');

module.exports = function (defaults) {
    var app = new EmberApp(defaults, {
        // Any other options
    });

    app.import("file1.js");
    app.import("file2.js");

    return app.toTree();
};
```

repository: ember-cli/ember-cli

gha_language: JavaScript

repo_name: ember-cli/ember-cli


text:
## Fabric Tools :

Fabric Tools is a pet project of mine where I share some tools and tips to work on Hyperledger Fabric.

 - Fabric Chaincode Writing Guidelines : https://gist.github.com/arnabkaycee/d4c10a7f5c01f349632b42b67cee46db

 - Hyperledger Fabric Proto UML :
An UML diagram of the protobufs used in Fabric: https://github.com/arnabkaycee/fabric-tools/blob/master/fabric-proto-uml.svg

repository: arnabkaycee/fabric-tools

repo_name: arnabkaycee/fabric-tools


text:
# <img src="https://raw.githubusercontent.com/bobocode-projects/resources/master/image/logo_transparent_background.png" height=50/>Introduction
The whole course consists of various exercises grouped by topics. Introduction itself is an exercise, so you can undersntand the idea on a simple example.

Each exercise has three major parts:
* **a task** – some logic that you should implement in order to complete the exercise 🤔
* **a test** – a corresponding test that verifies if you implement the task correctly ▶
* **a completed solution** - a branch `completed` that holds implemented task ✅

Go ahead and complete this exercise by implementing a method in `Introduction` class 💪

## You should have installed on your local machine ❗
* [JDK 11+](https://jdk.java.net/15/)
* [Git](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git)

## How to start ❓
* [clone](https://docs.github.com/en/github/creating-cloning-and-archiving-repositories/cloning-a-repository) this [repository](https://github.com/bobocode-projects/java-fundamentals-course) to your computer
* **open** the project via IDE

## Have a question? 🧐
* check out the [completed solution discussion](https://docs.github.com/en/github/creating-cloning-and-archiving-repositories/cloning-a-repository)
* or contact us via<EMAIL_ADDRESS>

repository: fugrusha/java-fundamentals-course

repo_name: fugrusha/java-fundamentals-course


text:
# CppClassDef
Helps generate class defs in C++

The reason why this is created is only that string concat cannot meet the need to generate a lot of classes. The usage is quite limited and the code is like rubbish. If anyone would ever need such a tool I would be grateful that you would try it. This can be really verbose, probably even more verbose than hand-writing all those classes all by yourself, but if you just want to skip the handwriting part or that you just enjoy the feeling of metaprogramming, maybe this can help you from inventing those square-shaped wheels once again.

# WARNING
This tool is written in C# and is only a library

Make sure you have a .NET SDK

# Usage
As you wish

# Limitations
A lot

repository: Xin-Shiyu/CppClassDef

repo_name: Xin-Shiyu/CppClassDef


text:
# Save Game Copier Legacy
Save Game Copier was my entry to the 2003 Segaxtreme Saturn Homebrew contest. It allowed you to burn saves to a CD, boot on a real Saturn, and copy them to the internal memory of the Saturn. I'm uploading the code for archival purposes only as there are better programs to use now such as Rockin B's [Save Game Manager](http://www.rockin-b.de/saturn-savegamemanager.html) or my Jo Engine rewrite of [Save Game Copier](https://github.com/slinga-homebrew/Save-Game-Copier).

# Screenshots
![Menu](menu.png)
![Screenshot 1](cdtointernal.png)
![Screenshot 2](floppymenu.png)
![credits](credits.png)

repository: slinga-homebrew/Save-Game-Copier-Legacy

repo_name: slinga-homebrew/Save-Game-Copier-Legacy


text:
# DEBUG

##Swift

####Code:
*#if DEBUG*
*    print("Debug mode")*
*#endif*

##### Project Settings:

1.
* Build Settings
* Preprocessing
* Preprocessor Macros
* under the debug section add the following:
DEBUG=1
$(inherited)

Or

2.
* Build Settings
* Swift Compiler - Custom Flags
* Other Swift Flags
* under the debug section add the following:
-D DEBUG

##Objective-C

####Code:

##### Project Settings:
* Build Settings
* Preprocessing
* Preprocessor Macros
* under the debug section add the following:
DEBUG=1
$(inherited)


text:
# react-interview-prep

My understanding about React

## Why React?

1. React makes it painless to create interactive UIs. Design simple views for each state in your application, and React will efficiently update and render just the right components when your data changes.
2. Declarative views make your code more predictable and easier to debug.
3. Build encapsulated components that manage their own state, then compose them to make complex UIs.
4. Since component logic is written in JavaScript instead of templates, you can easily pass rich data through your app and keep state out of the DOM.
5. We don't make assumptions about the rest of your technology stack, so you can develop new features in React without rewriting existing code.
6. React can also render on th server using Node and power mobile apps using React Native.

## Tasks

1. props in a child component
2. state with Hooks
3. state with inline conditional
4. react lifecycle methods

## What are the advantages of React16?

1. Better Error Handling (Error Boundaries)
2. New render return types: fragments and strings (as well as string and numbers)
3. Portals
4. Better Server-Side Rendering (Asynchronous Rendering)
5. Support for custom DOM attributes
6. Reduced File Size (concurrency, returning null from setState)
7. New Core Architecture (Component Stack Traces)
8. Browser Compatibility(Fiber) and MIT licensed

## Practice

1. React.memo()
2. React.lazy()
3. static contextType

## Disadvantages in React16

## React v17.0

## Available Scripts

In the project directory, you can run:

### `npm start` or `yarn start`

repository: Yue-design/react-interview-prep

repo_name: Yue-design/react-interview-prep


text:
---
layout: post
title:      "Classification Machine Learning Project"
date:       2019-11-10 18:34:54 -0500
permalink:  module_3_project
---

For my Module 3 project, I spent over a week before I landed on using a Spotify dataset to build a deep neural network and predict whether a song would be played or not played/skipped. My biggest challenge for two other topics of interest was finding an appropriate dataset.

My first choice was using the [Barcelona](https://www.kaggle.com/xvivancos/barcelona-data-sets) dataset from Kaggle to determine if you would have an accident based on your neighborhood. Unfortunately, this dataset didn’t have enough continuous features and/or the minimum amount of rows (50,000). The second dataset I was excited about (also from Kaggle) was about accidents in [France](https://www.kaggle.com/ahmedlahlou/accidents-in-france-from-2005-to-2016#places.csv) but I had the same issue where it didn’t have enough continuous features. So onto the project dataset I ended up working on as my Machine Learning Classification project.

The 2018 Spotify dataset consisted of user streaming session data and track information for a total of 51 features and over 100,000 rows. It required merging two CSV files together into a single set and then closely analyzing the feature set to reduce it down to 33 features in order to determine if a track will be played or skipped using the predictor variable **not_skipped**.

## Observe

After reading the CSV files through pandas, I immedinately renamed and reordered columns so they could be merged with an inner join into a single dataset with 167,880 rows and 50 columns.

![MergeCSV](https://drive.google.com/uc?export=view&id=1bEB9XnyLGFeZiY2IkhGfqsuOsMY1pQP5)

Based on the [Spotify documentation](https://developer.spotify.com/documentation/web-api/reference/object-model/), I was able to quickly identify 16 unnecessary / categorical features and dropped them.

## Scrub

After removing the unnecessary / categorical features, I then verified that there weren't any null values in the remaining columns.

![Drop](https://drive.google.com/uc?export=view&id=1abDOQCfR5sT9LDXIFma4T7-4mw4dQWxK)

![LambdaCheckNulls](https://drive.google.com/uc?export=view&id=1PT_j_wFQi6fmzqdAjWV4G6NIA5p0H-Lt)

I also checked to see how the data looked with my predictor variable **not_skipped**.

![ValueCounts](https://drive.google.com/uc?export=view&id=1TThk0gIzmtu0MXKO31GPgvJHKCYsgGHZ)

This showed that the data was unbalanced but I proceeded in exploring the data further knowing that I would need to come back and balance the data out.

## Explore

From the continuous dataset, I reviewed the distrubutions of the data and confirmed that there were only about nine features with normal distributions.

![Heatmap](https://drive.google.com/uc?export=view&id=1RvJqrEBYH-0qgPps4W4GKqoyLVsUwb1x)

The heatmap below showed multicolinarity for `beat_strength` and `bounciness` so `bounciness` is dropped before I test and train the data.

![Normalize](https://drive.google.com/uc?export=view&id=1zyaQouKUm9wEYiZqpzs7hV8cxbCv6SEG)

## Model

Because I know that my data is unbalanced (and in my first jupiter notebook I modeled my project without resampling that resulted in poor results - 50% accuracy), I tried SMOTE and nothing changed. I got stumped here and had to reach out to my instructor who lead me to the following steps to resample the data and balance it.

![resample](https://drive.google.com/uc?export=view&id=1R4K-kIqSue4h8Lx5REzgxl7xPnoVTKiD)
![resample2](https://drive.google.com/uc?export=view&id=1WIltT8pr05B3UU4t_u0jRzlhVF_NLS1Y)

So now that everything looked good, I was able to:

* run another logistic regression model with resampled data,
* validate my model with a confusion matrix, ROC Graph, random forest classifier,
* and hyperparameter tune with GridSearchCV

After all of these models were run, I was able to conclude that the model that provided best results was the first **Random Forest Classifier with 91% accuracy and precision**. This project was challenging but fun and I'm looking forward to the next one!


text:
# Interpreting common log messages

When debugging errors and outages, looking at the logs emitted by
JupyterHub is very helpful. This document tries to document some common
log messages, and what they mean.

## Failing suspected API request to not-running server

### Example

Your logs might be littered with lines that might look slightly scary

```
[W 2022-03-10 17:25:19.774 JupyterHub base:1349] Failing suspected API request to not-running server: /hub/user/<user-name>/api/metrics/v1
```

### Most likely cause

This likely means is that the user's server has stopped running but they
still have a browser tab open.   The
client side code (JupyterLab, Classic Notebook, etc) does not know
yet that the server is dead, and continues to make some API requests.
JupyterHub's architecture means that the proxy routes all requests that
don't go to a running user server to the hub process itself. The hub
process then explicitly returns a failure response, so the client knows
that the server is not running anymore. This is used by JupyterLab to
tell you your server is not running anymore, and offer you the option
to let you restart it.

Most commonly, you'll see this in reference to the `/api/metrics/v1`
URL, used by [jupyter-resource-usage](https://github.com/jupyter-server/jupyter-resource-usage).

### Actions you can take

This log message is benign, and there is usually no action for you to take.

## JupyterHub Singleuser Version mismatch

### Example

```
 jupyterhub version 1.5.0 != jupyterhub-singleuser version 1.3.0. This could cause failure to authenticate and result in redirect loops!
```

### Cause

JupyterHub requires the `jupyterhub` python package installed inside the image or
environment the user server starts in. This message indicates that the version of
the `jupyterhub` package installed inside the user image or environment is not
the same version as the JupyterHub server itself. This is not necessarily always a
problem - some version drift is mostly acceptable, and the only two known cases of
breakage are across the 0.7 and 2.0 version releases. In those cases, issues pop
up immediately after upgrading your version of JupyterHub, so **always check the JupyterHub
changelog before upgrading!**. The primary problems this _could_ cause are:

1. Infinite redirect loops after the user server starts
2. Missing expected environment variables in the user server once it starts
3. Failure for the started user server to authenticate with the JupyterHub server -
   note that this is _not_ the same as _user authentication_ failing!

However, for the most part, unless you are seeing these specific issues, the log
message should be counted as a warning to get the `jupyterhub` package versions
aligned, rather than as an indicator of an existing problem.

### Actions you can take

Upgrade the version of the `jupyterhub` package in your user environment or image
so it matches the version of JupyterHub running your JupyterHub server! If you
are using the [zero-to-jupyterhub](https://z2jh.jupyter.org) helm chart, you can find the appropriate
version of the `jupyterhub` package to install in your user image [here](https://jupyterhub.github.io/helm-chart/)

repository: rcthomas/jupyterhub

repo_name: rcthomas/jupyterhub


text:
Delete empty lines:
```
:v/./d
```

Add char to end of a line/every line:
```
:%norm A,
:11,20norm A,
:%s/$/,
```

Add to start of a line:
```
:s/^/#
:%s/^/#
```

Append to end of every line:
```
:%s/$/<--- ending dog
```
```
% - for each line
s - substitute
$ - EOL
dog - text to substitute
```
method 2:
```
:%norm Awoof
```
```
%			- for each line
norm	- type the following commands
A			- append
woof  - text to append

Get location of .vimrc in use:
```
:echo $MYVIMRC
```

Go to position ```xyz```
```
:goto 4200
```
Takes you to the 4200th byte in the buffer


text:
# [<img src="https://khan.github.io/KaTeX/katex-logo.svg" width="130" alt="KaTeX">](https://khan.github.io/KaTeX/) [![Build Status](https://travis-ci.org/Khan/KaTeX.svg?branch=master)](https://travis-ci.org/Khan/KaTeX)

KaTeX is a fast, easy-to-use JavaScript library for TeX math rendering on the web.

 * **Fast:** KaTeX renders its math synchronously and doesn't need to reflow the page. See how it compares to a competitor in [this speed test](http://jsperf.com/katex-vs-mathjax/).
 * **Print quality:** KaTeX’s layout is based on Donald Knuth’s TeX, the gold standard for math typesetting.
 * **Self contained:** KaTeX has no dependencies and can easily be bundled with your website resources.
 * **Server side rendering:** KaTeX produces the same output regardless of browser or environment, so you can pre-render expressions using Node.js and send them as plain HTML.

KaTeX supports all major browsers, including Chrome, Safari, Firefox, Opera, and IE 8 - IE 11.

## Usage

Download the built files from [the releases page](https://github.com/khan/katex/releases). Include the `katex.min.js` and `katex.min.css` files on your page:

```html
<link rel="stylesheet" href="/path/to/katex.min.css">
<script src="/path/to/katex.min.js"></script>
```

Call `katex.render` with a TeX expression and a DOM element to render into:

```js
katex.render("c = \\pm\\sqrt{a^2 + b^2}", element);
```

To generate HTML on the server, you can use `katex.renderToString`:

```js
var html = katex.renderToString("c = \\pm\\sqrt{a^2 + b^2}");
// '<span class="katex">...</span>'
```

Make sure to include the CSS and font files, but there is no need to include the JavaScript.

These APIs default to inline math typesetting; for display math you can prepend `\displaystyle` ([#66](https://github.com/Khan/KaTeX/issues/66)):

```js
katex.render("\\displaystyle " + formula, element);
// OR
var html = katex.renderToString("\\displaystyle " + formula);
```

## Contributing

See [CONTRIBUTING.md](CONTRIBUTING.md)

## License

KaTeX is licensed under the [MIT License](http://opensource.org/licenses/MIT).

repository: ghosthim/static

repo_name: ghosthim/static


text:
# PdfiumViewer.Code

将pvginkel/PdfiumViewer做了.Net Core 3.1的移植

## NuGet

```
Install-Package PdfiumViewer.Core
```

```
Install-Package PdfiumViewer.Native.x86_64.v8-xfa
Install-Package PdfiumViewer.Native.x86.v8-xfa
```

## 介绍

PdfiumViewer是基于PDFium项目的PDF查看器。

PdfiumViewer提供了许多用于处理PDF文件的组件：

PdfDocument是用于呈现PDF文档的基类；

PdfRenderer是一个WinForms控件，可以呈现PdfDocument；

PdfiumViewer是一个WinForms控件，它承载一个PdfRenderer控件，并且添加了一个工具栏来保存或打印PDF文件。

## Compatibility

The PdfiumViewer library has been tested with Windows XP , Windows 8 and Windows 10, and
is fully compatible with both. However, the native PDFium libraries with V8
support do not support Windows XP. See below for instructions on how to
reference the native libraries.

## Using the library

The PdfiumViewer control requires native PDFium libraries. These are not included
in the PdfiumViewer NuGet package. See the [Installation instructions](https://github.com/pvginkel/PdfiumViewer/wiki/Installation-instructions)
Wiki page for more information on how to add these.

## Note on the `PdfViewer` control

The PdfiumViewer library primarily consists out of three components:

* The `PdfViewer` control. This control provides a host for the `PdfRenderer`
  control and has a default toolbar with limited functionality;
* The `PdfRenderer` control. This control implements the raw PDF renderer.
  This control displays a PDF document, provides zooming and scrolling
  functionality and exposes methods to perform more advanced actions;
* The `PdfDocument` class provides access to the PDF document and wraps
  the Pdfium library.

The `PdfViewer` control should only be used when you have a very simple use
case and where the buttons available on the toolbar provide enough functionality
for you. This toolbar will not be extended with new buttons or with functionality
to hide buttons. The reason for this is that the `PdfViewer` control is just
meant to get you started. If you need more advanced functionality, you should
create your own control with your own toolbar, e.g. by starting out with
the `PdfViewer` control. Also, because people currently are already using the
`PdfViewer` control, adding more functionality to this toolbar would be
a breaking change. See [issue #41](https://github.com/pvginkel/PdfiumViewer/issues/41)
for more information.

## Building PDFium

Instructions to build the PDFium library can be found on the [Building PDFium](https://github.com/pvginkel/PdfiumViewer/wiki/Building-PDFium)
wiki page. However, if you are just looking to use the PdfiumViewer component
or looking for a compiled version of PDFium, these steps are not required.
NuGet packages with precompiled PDFium libraries are made available for
usage with PdfiumViewer. See the chapter on **Using the library** for more
information.

Alternatively, the [PdfiumBuild](https://github.com/pvginkel/PdfiumBuild) project
is provided to automate building PDFium. This project contains scripts to
build PdfiumViewer specific versions of the PDFium library. This project
is configured on a build server to compile PDFium daily. Please refer to
the [PdfiumBuild](https://github.com/pvginkel/PdfiumBuild) project page
for the location of the output of the build server. The PdfiumViewer specific
libraries are located in the `PdfiumViewer-...` target directories.

## License

PdfiumViewer is licensed under the Apache 2.0 license. See the license details for how PDFium is licensed.


text:
[![master-build Actions Status](https://github.com/jarnaud/republican-calendar/workflows/master-build/badge.svg)](https://github.com/jarnaud/republican-calendar/actions)
[![codecov](https://codecov.io/gh/jarnaud/republican-calendar/branch/master/graph/badge.svg)](https://codecov.io/gh/jarnaud/republican-calendar)

# Republican calendar

The Republican calendar :fr: was created during the French Revolution to remove all
religious and royalist references from the calendar.
This initiative was also part of a larger movement towards decimalisation.
It was officially used between 1793 and 1805 in France.

<img src="https://upload.wikimedia.org/wikipedia/commons/thumb/6/65/Calendrier-republicain-debucourt2.jpg/800px-Calendrier-republicain-debucourt2.jpg" alt="drawing" width="200"/>

This library allows easy conversion between Gregorian and Republican dates.
It can be used for dates after 1805 (see details about non-historical periods below).

## Dependency

With Maven, add to your dependencies:

```xml
<dependency>
    <groupId>com.github.jarnaud</groupId>
    <artifactId>republican-calendar</artifactId>
    <version>1.3</version>
</dependency>
```

With SBT:

```sbt
libraryDependencies += "com.github.jarnaud" % "republican-calendar" % "1.3"
```

NB: To find the latest version, please refer to [Maven search](https://search.maven.org/artifact/com.github.jarnaud/republican-calendar).

## Quickstart

### Dates

- To convert a Gregorian local date into a Republican date:

```java
LocalDate date = LocalDate.of(1792, 9, 22);
RDate rDate = RDate.of(localDate);
```

- To convert a Republican date into a Gregorian date:

```java
RDate rDate = RDate.of(1, RMonth.Vendemiaire, 1);
LocalDate date = c.toLocalDate();
```

- `RDate` represents a Republican date and provides some utility methods:
`isBefore(RDate)`, `isSextile()`, `plusDays(int)`.

### Time

The Republican calendar uses the decimal time. Each day contains 10 hours, each hour contains 100 minutes
and each minute contains 100 seconds. You can convert between normal and Republican time to the nanosecond precision
that way:

- To convert a normal time into a Republican time:

```java
LocalTime localTime=LocalTime.of(16, 48, 0);
RTime rTime=RTime.of(localTime);
```

- To convert a Republican time into a normal time:

```java
RTime rTime=RTime.of(7, 0);
LocalTime localTime=rTime.toLocalTime();
```

### Date and time

We provide `RDateTime` which is an equivalent to `LocalDateTime` in the Republican calendar.
It combines `RDate` and `RTime`. You can use it in the same way:

- To convert a normal date and time into a Republican date and time:

```java
LocalDateTime dateTime=LocalDateTime.of(1818,12,12,11,7,58);
RDateTime rdt = RDateTime.of(dateTime);
```

- To convert a Republican date and time into a normal date and time:
```java
RDateTime rdt = RDateTime.of(27, RMonth.Frimaire, 21, 4, 63, 87);
LocalDateTime dateTime=rdt.toLocalDateTime();
```

*NB: for RTime and RDateTime, it may happen that converting to normal time then back doesn't
give the original second. It's because decimal seconds are not aligned with the normal seconds.
You can call `.roundSecond()` on both to round the time to the nearest second.*

## Non-historical periods

The Republican calendar was used historically between 1791 and 1805.
However, we can use this calendar for other dates, based on following rules:

- Dates before 1792-09-22 (first day of Republican calendar) are not defined.
- Dates after 1806-01-01 (end of Republican calendar) are estimated based on the commonly used Romme method.

## Links and references

More about the Republican calendar (including current date):
https://en.wikipedia.org/wiki/French_Republican_calendar

More about the decimal time:
https://en.wikipedia.org/wiki/Decimal_time

**Note about online converters:**
A lot of online converters are incorrect for dates outside the period of real historical
usage of the Republican calendar, mostly due to improper handling of leap years.

repository: jarnaud/republican-calendar

repo_name: jarnaud/republican-calendar


text:
sparklib - client interface to the Spark Lighter service
========================================================

 This android library helps you to connect to [senseable's](http://senseable.eu)
Spark Bluetooth Lighter. Cigarette events are stored locally and you can connect
to exactly one Lighter at a time. The Spark companion App needs to be installed
for this library to be used. When including this library in your App, the user
will be presented with a prompt to install the companion App.

# Installation

 For gradle builds you can use npm to resolve the dependency by adding a

    repositories { jcenter() }
    dependencies { compile 'eu.senseable:sparklib:1.2.3'  }

 to the build.gradle file of your application.

# Usage

 The interface is fully defined in the [Spark](https://senseable.github.io/sparklib/eu/senseable/sparklib/Spark.html) class. You can access the API docs [here](https://senseable.github.io/sparklib/). It's simplest to implement the provided callbacks, which get called whenever something is changing and once at registration time. For example to access the currently stored events on the device, you could do something like this:

    public void onCreate() {
      mSpark = new Spark(this, mSparkCalls);
    }

    public void onDestroy() {
      mSpark.close();
    }

    private Spark.Callbacks mSparkCalls = new Spark.Callbacks.Stub() {
      public void onEventsChanged(List<Spark.Event> events) {
         if (events.size() == 0)
           return;

         /** At this point you can access the list of events stored on the SmartPhone,
           * this function gets called when new events were detected from the lighter,
           * and once shortly after the Spark object was created.
           */

         Date first = events.get(0).beg;
         Log.d(TAG, String.format("got %d new events, starting at %s", events.size(), first.toString()));
      }
    }

repository: senseable/sparklib

repo_name: senseable/sparklib


text:
# vertx-modular-router
Lightweight API to create modular routers for Vert.x REST endpoints.

# Developing a Service

Create your own service by extending the `io.devcon5.vertx.services.AbstractService`.

- define a mount point. This is the context root relative to the root of your application. All further
 routes are defined below this mountpoint

- create a router. Create a router and define your routes as you would with any other Vert.x router

- create a `META-INF/services/io.devcon5.vertx.services.Service` file and put your service's fully qualified
class names in it

- Optional: if your service requires a Verticle to be deployed, this is best done by overriding the `start` method
and deploy your Verticle as you probably would in the start method of an AbstractVerticle

Example:

```java
public class TestService extends AbstractService<TestService> {

  @Override
  public Router createRouter() {

    Router router = Router.router(vertx());
    router.get("/world").handler(ctx -> ctx.response().end("Hello world"));
    return router;
  }

  @Override
  public String mountPoint() {

    return "/hello";
  }
}
```

# Build an App with modular router
In order to build an app that assembles all modular Verticles, you create your HTTP Server and a router as you would
with any other Vert.x Web application.

After creating and initializing the Router, but _before_ adding a StaticContentHandler.

The services are discovered automatically via the Java ServiceLoader mechanism when `Service.mountAll` is invoked.
The method takes three arguments:
- the parent router
- the config that is passed to _every_ service
- the authProvider for services that require authentication

```java

final AuthProvider auth = ...
final JsonObject config = ...

//create the main router
final Router router = Router.router(vertx);

//add global handler
router.route().handler(BodyHandler.create());
router.route().handler(CookieHandler.create());
router.route().handler(SessionHandler.create(LocalSessionStore.create(vertx)));
router.route().handler(UserSessionHandler.create(cognitoAuth));

//mount all services that are on the classpath
Service.mountAll(router, config, auth);

//static handler should be added after everything else
router.route().handler(StaticHandler.create());
```

and finally create the server with the router to handle the requests
```java
vertx.createHttpServer().requestHandler(router::accept).listen(8080);
```

gha_language: Java


text:
# Git Search

This project is an application where users find thei git hub details using their username.

 ## Author's Name
    -Annick Francine MAJYAMBERE
    -A new web-developer
  ## Setup instructions

    -Visit the website using the github online link

  ### BDD

  | command | Description | How to run |
  | --- | --- |-----|
  | using AngularJs | landing page for Git-search web app | Visit the website

   #### Technologies used

     -AngularJs
     -Bootstrap

   ### Contact information

    Phone number=+250786409154
<EMAIL_ADDRESS>
  ### MIT License and Copyright information

  [MIT](https://choosealicense.com/licenses/mit/)
  Copyright ©2019 Annick-Francine-M

repository: mfannick/Git-search

gha_language: TypeScript

repo_name: mfannick/Git-search


text:
# About The Session - "Web Development Basics and HTML"

This session revolves around the basics of web, ranging from what browser,server,internet are.
We will be giving a brief overview of how structuring of webpage is done using HTML.

## About the Documentation

This is the **Cheat Sheet** opened for everyone to use during the hackathon. There are resources and tools embeded inside which you can use as a participant.

## Softwares And Installations

You can install any of these Editors,
* [Sublime Text](https://www.sublimetext.com/)
* [Atom](https://atom.io/) [Preferable, will be using in the session]
* NotePad - May Be present in your system already
* One [GitHub](https://github.com/) account
* Any of the browsers - Like Chrome, Safari,Opera etc.

## Content

You can find the slides here - Slides

* [How Does The Internet Work](https://github.com/Abhijit2505/Front-End-Hackathon-Resources/blob/master/First%20Session/DOC.md#how-does-the-internet-work-)
* [What is HTML](https://github.com/Abhijit2505/Front-End-Hackathon-Resources/blob/master/First%20Session/DOC.md#what-is-html-)
* Tags and Elements Cheatsheet

    * [comments](https://github.com/Girlscript-Chapter-Bilaspur/Front-End-Hackathon-Resources/tree/master/First%20Session#comments)
    * [html](https://github.com/Girlscript-Chapter-Bilaspur/Front-End-Hackathon-Resources/tree/master/First%20Session#html)
    * [head](https://github.com/Girlscript-Chapter-Bilaspur/Front-End-Hackathon-Resources/tree/master/First%20Session#head)
    * [body](https://github.com/Girlscript-Chapter-Bilaspur/Front-End-Hackathon-Resources/tree/master/First%20Session#body)
    * [heading](https://github.com/Girlscript-Chapter-Bilaspur/Front-End-Hackathon-Resources/tree/master/First%20Session#heading)
    * [paragraph](https://github.com/Girlscript-Chapter-Bilaspur/Front-End-Hackathon-Resources/tree/master/First%20Session#paragraph)
    * [br](https://github.com/Girlscript-Chapter-Bilaspur/Front-End-Hackathon-Resources/tree/master/First%20Session#br)
    * [anchor](https://github.com/Girlscript-Chapter-Bilaspur/Front-End-Hackathon-Resources/tree/master/First%20Session#anchor)
    * [img](https://github.com/Girlscript-Chapter-Bilaspur/Front-End-Hackathon-Resources/tree/master/First%20Session#img)
    * [list](https://github.com/Girlscript-Chapter-Bilaspur/Front-End-Hackathon-Resources/tree/master/First%20Session#list)
    * [Text Formatting](https://github.com/Girlscript-Chapter-Bilaspur/Front-End-Hackathon-Resources/tree/master/First%20Session#text-formatting)

   * Some Intermediate Stuffs

      * [Making HTML Table Element](https://github.com/Girlscript-Chapter-Bilaspur/Front-End-Hackathon-Resources/tree/master/First%20Session#making-html-table-element)

### How Does The Internet Work ?

The Internet is made up of a massive network of specialized computers called routers. Each router’s job is to know how to move packets along from
their source to their destination. A packet will have moved through multiple routers during its journey.

Along with the session slides, here is an addition from [Medium](https://medium.com/), Have a visit to the link - [How Does The Internet Work?](https://medium.com/@User3141592/how-does-the-internet-work-edc2e22e7eb8#:~:text=The%20Internet%20is%20made%20up,next%2C%20it's%20called%20a%20hop.)
to get an entire overview of how the internet works.

### What is HTML ?

* **HTML** stands for **Hypertext Markup Language**. It allows the user to create and structure sections, paragraphs, headings, links, and blockquotes
for web pages and applications.

* HTML is not a programming language, meaning it doesn’t have the ability to create dynamic functionality. Instead, it makes it possible to organize
and format documents, similarly to Microsoft Word. That's why it is known as **Mark Up Language**.
* HTML documents are files that end with a **.html** or **.htm** extension. You can view then using any **web browser** (such as Google Chrome, Safari, or Mozilla Firefox).
The browser reads the HTML file and renders its content so that internet users can view it.
* Usually, the average website includes several different **HTML pages**. For instance: home pages, about pages, contact pages would all have separate HTML documents.
* Each HTML page consists of a set of **tags** (also called elements), which you can refer to as the building blocks of web pages.
They create a hierarchy that structures the content into sections, paragraphs, headings, and other content blocks.

* Most HTML elements have an opening and a closing that use the ```<tag></tag>``` syntax.

### Tags and Elements CheatSheet

#### comments

```<!--comments--->``` is used to add comments.

#### html

The ```<html></html>``` represents the root (top-level element) of an HTML document, so it is also referred to as the root element.
All other elements must be descendants of this element.

**Example**

 ```html
<!DOCTYPE html>
 <html lang="en">
   <head>...</head>
   <body>...</body>
 </html>
```

Providing a **lang** attribute with a valid IETF identifying language tag on the html element will help
screen reading technology determine the proper language to announce. The identifying language tag should describe
the language used by the majority of the content of the page. Without it, screen readers will
typically default to the operating system's set language, which may cause mispronunciations.

Including a valid **lang** declaration on the html element also ensures that important metadata contained in the page's
```<head>```, such as the page's ```<title>```, are also announced properly.

#### head

The ```<head>``` provides general information (metadata) about the document, including its title and links to its scripts and style sheets.

**Example**

  ```html
<html>
   <head>
     <title>Document title</title>
   </head>
 </html>
```

The HTML Title element ```<title>``` defines the document's title that is shown in a browser's title bar or a page's tab.
It only contains text and tags within the element are ignored.

#### body

The ```<body>``` represents the content of an HTML document. There can be only one ```<body>``` element in a document.

**Example**

  ```html
<html>
   <head>
     <title>Document title</title>
   </head>
   <body>
     <p>This is a paragraph</p>
   </body>
 </html>
```

#### heading

This one is used to create headings with six different tags ranging from **h1** to **h6**, Have a look at the example below,

**Example**

 ```html
 <h1>Heading level 1</h1>
 <h2>Heading level 2</h2>
 <h3>Heading level 3</h3>
 <h4>Heading level 4</h4>
 <h5>Heading level 5</h5>
 <h6>Heading level 6</h6>
```

Heading level 1

Heading level 2

Heading level 3

Heading level 4

Heading level 5

Heading level 6

#### paragraph

The ```<p>``` represents a paragraph. Paragraphs are usually represented in visual media as blocks of text separated from adjacent blocks by blank
lines and/or first-line indentation, but HTML paragraphs can be any structural grouping of related content, such as images or form fields.

**Example**

 ```html
<p>This is the first paragraph of text.
   This is the first paragraph of text.
   This is the first paragraph of text.
   This is the first paragraph of text.</p>
 <p>This is the second paragraph.
   This is the second paragraph.
   This is the second paragraph.
   This is the second paragraph.</p>
```

#### br

The ```<br>``` produces a line break in text (carriage-return). It is useful for writing a poem or an address, where the division of lines is significant.

**Example**

 ```html
GirlScript Bilaspur<br>
 Bilaspur,Chhattisgarh<br>
 123456<br>
 India<br>
```

GirlScript Bilaspur

Bilaspur,Chhattisgarh

123456

India

#### anchor

The ```<a>``` (or anchor element) creates a hyperlink to other web pages, files, locations within the same page, email addresses, or any other URL.

**Example**

 ```html
<a href="https://girlscript-chapter-bilaspur.github.io/Forntend-Hackathon/">
 External Link
 </a>
```

External Link

##### Common Attributes -
##### href
Contains a URL or a URL fragment that the hyperlink points to.
A URL fragment is a name preceded by a hash mark (#), which specifies an internal target location (an ID of an HTML element) within the current document. URLs are not restricted to Web (HTTP)-based documents, but can use any protocol supported by the browser. For example, file:, ftp:, and mailto: work in most browsers.
You can use href="#top" or the empty fragment href="#" to link to the top of the current page. This behavior is specified by HTML5.

##### rel
Specifies the relationship of the target object to the link object. The value is a space-separated list of link types.

##### target
Specifies where to display the linked URL. It is a name of, or keyword for, a browsing context: a tab, window, or . The following keywords have special meanings:
* **_self**: Load the URL into the same browsing context as the current one. This is the default behavior.
* **_blank**: Load the URL into a new browsing context. This is usually a tab, but users can configure browsers to use new windows instead.
* **_parent**: Load the URL into the parent browsing context of the current one. If there is no parent, this behaves the same way as _self.
* **_top**: Load the URL into the top-level browsing context (that is, the "highest" browsing context that is an ancestor of the current one, and has no parent). If there is no parent, this behaves the same way as _self.

#### img

The ```<img>``` embeds an image into the document. It is a replaced element.

**Example**

 ```html
<img src="book_photo.png" alt="A Book Photo">
```

##### Common Attributes -

#### alt
This attribute defines an alternative text description of the image.
Note: Browsers do not always display the image referenced by the element. This is the case for non-graphical browsers
(including those used by people with visual impairments), if the user chooses not to display images, or if the browser
cannot display the image because it is invalid or an unsupported type. In these cases, the browser may replace the image
with the text defined in this element's alt attribute. You should, for these reasons and others, provide a useful value for
alt whenever possible.

#### height
The intrinsic height of the image in pixels.

#### src
The image URL. This attribute is mandatory for the  element. On browsers supporting srcset,
src is treated like a candidate image with a pixel density descriptor 1x unless an image with this
pixel density descriptor is already defined in srcset, or unless srcset contains 'w' descriptors.

#### width
The intrinsic width of the image in pixels.

#### list

```<li></li>``` is used to create items in a list.

##### unorderd list
The ```<ul>``` represents an unordered list of items, typically rendered as a bulleted list.

**Example**

```html
<ul>
  <li>first item</li>
  <li>second item</li>
  <li>third item</li>
</ul>
```

first item

second item

third item

##### ordered list
The ```<ol>``` represents an ordered list of items, typically rendered as a numbered list.

**Example**

 ```html
<ol>
   <li>first item</li>
   <li>second item</li>
   <li>third item</li>
 </ol>
```

first item

second item

third item

#### Text Formatting

* BOLD TEXT ```<b>---</b>```
* BIG TEXT ```<big>---</big>```
* ITALIC TEXT ```<i>---</i>```
* SMALL TEXT ```<small>---</small>```
* STRONG TEXT ```<strong>---</strong>```
* SUBSCRIPTED TEXT ```<sub>---</sub>```
* SUPERSCRIPTED TEXT ```<sup>---</sup>```
* INSERTED TEXT ```<ins>---</ins>```
* DELETED TEXT ```<del>---</del>```

#### Some Intermediate Stuffs

##### Making HTML Table Element

**Example**

   ```html
<table border='1'>
         <thead>
           <tr>
             <td>
               <em><b>Name</b></em>
             </td>
             <td>
               <em><b>Place</b></em>
             </td>
             <td>
               <em><b>Mobile Number</b></em>
             </td>
           </tr>
         </thead>
         <tbody>
           <tr>
             <td>
               Abhijit
             </td>
             <td>
               Bilaspur
             </td>
             <td>
<PHONE_NUMBER>484
             </td>
           </tr>
         </tbody>
         <tbody>
           <tr>
             <td>
               Ruhi
             </td>
             <td>
               Bilaspur
             </td>
             <td>
<PHONE_NUMBER>714
             </td>
           </tr>
         </tbody>
         <tbody>
           <tr>
             <td>
               Abhishek
             </td>
             <td>
               Bilaspur
             </td>
             <td>
<PHONE_NUMBER>141
             </td>
           </tr>
         </tbody>
         <tbody>
           <tr>
             <td>
               Ajay
             </td>
             <td>
               Bilaspur
             </td>
             <td>
<PHONE_NUMBER>494
             </td>
           </tr>
         </tbody>
         <tbody>
           <tr>
             <td>
               Deepesh
             </td>
             <td>
               Bilaspur
             </td>
             <td>
<PHONE_NUMBER>454
             </td>
           </tr>
         </tbody>
       </table>
```

            Name

            Place

            Mobile Number

            Abhijit

            Bilaspur

<PHONE_NUMBER>484

            Ruhi

            Bilaspur

<PHONE_NUMBER>714

            Abhishek

            Bilaspur

<PHONE_NUMBER>141

            Ajay

            Bilaspur

<PHONE_NUMBER>494

            Deepesh

            Bilaspur

<PHONE_NUMBER>454

**Explanation Of Tags**

* ```<table></table>``` - The ```<table>``` represents tabular data — that is, information presented in a two-dimensional
table comprised of rows and columns of cells containing data.
* ```<thead></thead>``` - The ```<thead>``` defines a set of rows defining the head of the columns of the table.
* ```<tbody></tbody>``` - The HTML Table Body element ```<tbody>``` encapsulates a set of table row ```<tr>``` elements,
indicating that they comprise the body of the table ```<table>```.
* ```<tr></tr>``` - The ```<tr>``` defines a row of cells in a table. The row's cells can then be established using a mix of ```<td>``` (data cell) and ```<th>``` (header cell) elements.

##### HTML form element

```html
<form action="" method="get" class="form-example">
<div class="form-example">
 <label for="name">Enter your name: </label>
 <input type="text" name="name" id="name" required>
</div>
<div class="form-example">
 <label for="email">Enter your email: </label>
 <input type="email" name="email" id="email" required>
</div>
<div class="form-example">
 <input type="submit" value="Follow Me">
</div>
   ```

**Explanation Of Tags**

* **action** - The URI of a program that processes the form information. This value can be overridden by a formaction attribute on a ```<button>``` or ```<input>``` element.
* **name** - The name of the form
* **target** - A name or keyword indicating where to display the response that is received after submitting the form. In HTML 4, this is the name/keyword for a frame. In HTML5, it is a name/keyword for a browsing context (for example, tab, window, or inline frame). The following keywords have special meanings:
   * **_self**: Load the response into the same HTML 4 frame (or HTML5 browsing context) as the current one. This value is the default if the attribute is not specified.
   * **_blank**: Load the response into a new unnamed HTML 4 window or HTML5 browsing context.
   * **_parent**: Load the response into the HTML 4 frameset parent of the current frame, or HTML5 parent browsing context of the current one. If there is no parent, this option behaves the same way as ```_self```.
   * **_top**: HTML 4: Load the response into the full original window, and cancel all other frames. HTML5: Load the response into the top-level browsing context (i.e., the browsing context that is an ancestor of the current one, and has no parent). If there is no parent, this option behaves the same way as ```_self```.
   * **iframename**: The response is displayed in a named ```<iframe>```.
* **method** - The HTTP method that the browser uses to submit the form. Possible values are:
   * **post**: Corresponds to the HTTP POST method ; form data are included in the body of the form and sent to the server.
   * **get**: Corresponds to the HTTP GET method; form data are appended to the action attribute URI with a ```?``` as separator, and the resulting URI is sent to the server. Use this method when the form has no side-effects and contains only ASCII characters.
This value can be overridden by a formmethod attribute on a ```<button>``` or ```<input>``` element.

For more details on HTML forms, please visit - [HTML Design Forms](https://www.geeksforgeeks.org/html-design-form/)

#### References

* [DevDocs](https://devdocs.io/)
* [Mozilla Developer Network](https://developer.mozilla.org/en-US/)
* [W3 Schools](https://www.w3schools.com/)

#### Contributors

* [Shalu Kumari](https://www.linkedin.com/in/shalu-kumari-42ab8019b/)
* [Prashashti Pankaj](https://www.linkedin.com/in/prashasti-pankaj-8875a8171/)
* [Abhijit Tripathy](https://www.linkedin.com/in/abhijit-tripathy-415912187/)

path: /First Session/README.md


text:
# Informatiquiz

This is a PHP web application designed to take quizzes in the classroom. The types of questions that can be asked are designed especially for computer science education.

## Running
Everything is pre-configured:

```
docker-compose up -d
```

repository: cpAdm/informatiquiz

repo_name: cpAdm/informatiquiz


text:
---
humanName: Template
# Required. Can have whitespace. Should be titleized.
heading: 'Backstage Template Plugin'
# Keep it short
lead: 'Describe the problem that the plugin will solve for users'
attribution:
  text: Spotify
  href: https://spotify.com

seo:
  # Don't forget to end with "| Roadie"
  title: 'Backstage Template Plugin | Roadie'
  description: |
    What would you want to know before clicking this in Google. Think about searcher intent.
    Don't forget to keep it under 160 chars.

# This must be a relative path. It should start with ../
# The overall size of the file should be approximately 200 by 200.
# The image in the file should be approximately 100 by 100 pixels. It needs space around it.
logoImage: '../../assets/logos/sentry/sentry-glyph-light-200x184.png'

# This must be a relative path. It should start with ../
coverImage: '../../assets/backstage/plugins/sentry-plugin-1604x716.png'
coverImageAlt: 'Explain what is in the image'

# Instructions for someone who wants to use this plugin.
# languages used here must be listed in the .babelrc

gettingStarted:
  # What will this step accomplish?
  - intro: Install the plugin
    language: bash
    code: yarn add @roadiehq/backstage-plugin-github-pull-requests

  - intro: Import it into your Backstage application
    language: typescript
    code: |
      // packages/app/src/apis.ts
      import { GithubPullRequestsClient, githubPullRequestsApiRef } from '@roadiehq/backstage-plugin-github-pull-requests';

  - intro: 'Heres where things get good...'
    language: typescript
    code: |
      // packages/app/src/plugins.ts
      export { plugin as Template } from '@backstage/plugin-template';
---

The Backstage backend must have access to a `SENTRY_TOKEN` environment variable. The


text:
# Graduate ScheduleDaemonSetPods to GA

## Table of Contents

<!-- toc -->
- [Release Signoff Checklist](#release-signoff-checklist)
- [Summary](#summary)
- [Motivation](#motivation)
  - [Goals](#goals)
  - [Non-Goals](#non-goals)
- [Proposal](#proposal)
  - [Implementation Details/Notes/Constraints](#implementation-detailsnotesconstraints)
  - [Risks and Mitigations](#risks-and-mitigations)
- [Design Details](#design-details)
  - [Test Plan](#test-plan)
    - [Existing Tests](#existing-tests)
  - [Graduation Criteria](#graduation-criteria)
- [Implementation History](#implementation-history)
<!-- /toc -->

## Release Signoff Checklist

- [x] kubernetes/enhancements issue in release milestone, which links to KEP (this should be a link to the KEP location in kubernetes/enhancements, not the initial KEP PR)
- [x] KEP approvers have set the KEP status to `implementable`
- [x] Design details are appropriately documented
- [x] Test plan is in place, giving consideration to SIG Architecture and SIG Testing input
- [x] Graduation criteria is in place
- [x] "Implementation History" section is up-to-date for milestone
- [x] User-facing documentation has been created in [kubernetes/website], for publication to [kubernetes.io]
- [x] Supporting documentation e.g., additional design documents, links to mailing list discussions/SIG meetings, relevant PRs/issues, release notes

## Summary

ScheduleDaemonSetPods has been created in the past to schedule DaemonSet Pods by the default scheduler. We wish to graduate ScheduleDaemonSetPods feature to make scheduling decisions only in the scheduler and remove the scheduling related code in the DaemonSetController.

## Motivation

ScheduleDaemonSetPods has been beta'ed in 1.12.

### Goals

+ Plan to promote ScheduleDaemonSetPods to the stable version.
+ Remove scheduling related codes in DaemonSetController.

### Non-Goals

+ Changing API field or meaning

## Proposal

### Implementation Details/Notes/Constraints

ScheduleDaemonSetPods attaches node affinity to DaemonSet pods, which let the default kubernetes scheduler to schedule pods on specific nodes. The DaemonSet controller uses several scheduler predicates to calculate the nodes which need to schedule DaemonSet pods and create pods with specific NodeAffinity.

### Risks and Mitigations

The major concern for graduating ScheduleDaemonSetPods to the stable version could be the overhead to the scheduler and the startup time of daemons. After we graduate this feature, the scheduler would select nodes for all of the DaemonSet pods, which may cause a lot of pods with NodeAffinity to be processed.

## Design Details

### Test Plan

#### Existing Tests

ScheduleDaemonSetPods currently has multiple tests in various components that use the feature.

### Graduation Criteria

**Note:** *Section not required until targeted at a release.*

- [x] Graduate ScheduleDaemonSetPods to GA
- [x] Remove suspenedDaemonPods which handles Pod deleted on the nodes
- [x] Refactor nodeShouldRunDaemonPod to remove useless return values
- [x] Update documents to reflect the changes

## Implementation History

+ ScheduleDaemonSetPods was introduced in Kubernetes 1.11 as an alpha version.
+ ScheduleDaemonSetPods was graduated to beta in Kubernetes 1.12.

repository: kubernetes/enhancements

gha_language: Go

repo_name: kubernetes/enhancements


text:
---
date: 2019-10-09
linktitle: "Private Images"
title: Private Images and Registry Credentials
weight: 20200
---

When packaging and delivering an enterprise application, a common problem is the need to include private Docker images.
Most enterprise applications consist of public images (postgres, mysql, redis, elasticsearch) and private images (the application images).

When delivering a Kots application through [vendor.replicated.com](https://vendor.replicated.com), there’s built-in support to include private images -- without managing or distributing actual registry credentials to your customer.
The license file grants revokable image pull access to private images, whether these are stored in the Replicated private registry, or another private registry server that you’ve decided to use.

If your application images are already available in a private, but accessible image registry (such as Docker Hub, quay.io, ECR, GCR, Artifactory or such), then your application licenses can be configured to grant proxy, or pull-through access to the assignee without giving actual credentials to the customer.
This is useful and recommended because it prevents you from having to modify the process you use to build and push application images, and it gives you the ability to revoke a customer’s ability to pull (such as on trial expiration).
This External Registry is shared across all KOTS applications in a team, allowing images to be used across multiple apps.

To configure access to your private images, log in to [vendor.replicated.com](https://vendor.replicated.com), and click on the images menu item under your application.
Here, there’s a button named “Add External Registry”.
Fill this modal out with an endpoint (quay.io, index.docker.io, gcr.io, etc) and provide a username and password to Replicated that has pull access.
For more information, see the documentation on our registry.
Replicated will store your username and password encrypted and securely, and it (and the encryption key) will never leave our servers.

![Add External Registry](/images/add-external-registry.png)

Your application YAML will reference images that it cannot access.
Kots and kotsadm recognize this, and will patch the YAML using Kustomize to change the image name.
When kots is attempting to install an application, it will attempt to load image manifest using the image reference from the PodSpec.
If it’s loaded successfully, no changes will be made to the application.
If a 401 is received and authentication is required, kots will assume that this is private image that needs to be proxied through the Replicated registry-proxy service.
A patch will be written to the midstream kustomization.yaml to change this image name during deployment.

For example, given a private image hosted at `quay.io/my-org/api:v1.0.1`, a deployment and pod spec may reference it like this:

```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: example
spec:
  template:
    spec:
      containers:
        - name: api
          image: quay.io/my-org/api:v1.0.1
```

When the application is deployed, kots will detect that it cannot access the image at quay.io and will create a patch in the `midstream/kustomization.yaml`:

```yaml
apiVersion: kustomize.config.k8s.io/v1beta1
bases:
- ../../base
images:
- name: quay.io/my-org/api:v1.0.1
  newName: proxy.replicated.com/proxy/my-kots-app/quay.io/my-org/api
```

This will change that image name everywhere it appears.

In addition, kots will create an imagePullSecret dynamically and automatically at install time.
This secret is based on the customer license, and will be used to pull all images from `proxy.replicated.com`

Images hosted at `registry.replicated.com` will not be rewritten.
However, the same secret will be added to those PodSpecs as well.

## Additional namespaces

When deploying pods to namespaces other than the KOTS application namespace, the namespace must be added to the `additionalNamespaces` attribute of the [Application](/reference/v1beta1/application/) spec.
This will ensure that a secret named `kotsadm-replicated-registry` will get auto-provisioned by KOTS in the namespace to allow the pod to pull the image.
For more information about the `additionalNamespaces` attribute see [this doc](/vendor/operators/additional-namespaces/).

gha_language: SCSS


text:
To use this control via git submodule, please follow the steps below:-

````bash
$ git submodule add http://github.com/chiunam/CTAssetsPickerController
````

1. Run `create_bundle` script to create a resource bundle in `CTAssetsPickerController/CTAssetsPickerController.bundle`. You will have to run this script to create a new bundle **every time** you update this library.
2. Drag `CTAssetsPickerController` folder in your project and add to your targets.
3. Add `AssetsLibrary.framework` and `MediaPlayer.framework`.

repository: msching/CTAssetsPickerController

repo_name: msching/CTAssetsPickerController


text:
# Changelog

## [Unreleased]

 - Updated Facebook Graph API version to v14.0
 - Add option to download Redash result as csv
 - Added Google Ads report
 - Added support for default drive id in Google Drive profile
 - Migrate to PyDrive2 from PyDrive

## [1.4.0] - 2020-07-12

 - Updated Facebook Graph API version to v10.0
 - Updated RTBHouse API version to 5
 - Allow overwriting configuration values from cli
 - Added BingAds report

## [1.3.8] - 2020-02-04

 - Patch PyDrive to work with new version of httplib2

## [1.3.7] - 2020-02-03

 - Fixed interaction between google api and httplib2 libraries

## [1.3.6] - 2020-01-30

 - Added support for shared drives in Google Drive report and result
 - Reash parameters can now be templated

## [1.3.5] - 2019-12-18

 - Updated Facebook API version to 5.0

## [1.3.4] - 2019-09-11

 - FileResult now accepts extra arguments for pandas io methods
 - Allow specifying plain sql queries instead of files

## [1.3.3] - 2019-08-16

 - RTBHouse report now uses API instead of sdk

## [1.3.2] - 2019-07-02

 - Paramiko upgraded to 2.6.0

## [1.3.1] - 2019-06-10

 - Google Drive API calls now are retried on unexpected errors

## [1.3.0] - 2019-05-24

 - Credentials can now be specified through environment variable
 - Added Partitioned Result
 - Updated required pandas version to 0.23.4
 - Updated required psycopg2 version to 2.7.7
 - Updated Facebook API version to 3.3

## [1.2.2] - 2019-05-17

 - Updated Facebook API version to 3.2
 - Updated required googleads version to 19.0.0

## [1.2.1] - 2019-03-21

 - Updated adwords version to v201809

## [1.2.0] - 2019-02-15

 - Added reports from RTBHouse and Rakuten
 - Added fixed columnar result
 - Added a possiblity to configure Adwords and Facebook reports with relative dates.
 - Added an option to refresh a Redash query before downloading
 - Added a parameter/configuration to override current date.
 - Updated Facebook API version to 3.1
 - Updated required requests version to >= 2.21.0
 - Updated required SQLAlchemy version to == 1.2.17
 - Added presto optional dependency

## [1.1.1] - 2018-09-10

 - Added password parameter to SFTP result
 - Fixed mime_type parameter for Google Drive result

## [1.1.0] - 2018-06-24

 - Added Python 3 support (>= 3.5)
 - Updated adwords version to v201806

## [1.0.1] - 2018-05-17

 - Bugfixes

## [1.0.0] - 2018-05-09

 - First release

repository: gseva/laika

repo_name: gseva/laika


text:
# AAO-React-Native [![Android/Windows build status](https://ci.appveyor.com/api/projects/status/qi83hnivu0rkgbvo?svg=true)](https://ci.appveyor.com/project/hawkrives/aao-react-native) [![Android/Linux build status](https://travis-ci.org/StoDevX/AAO-React-Native.svg?branch=master)](https://travis-ci.org/StoDevX/AAO-React-Native) [![Coverage Status](https://coveralls.io/repos/github/StoDevX/AAO-React-Native/badge.svg)](https://coveralls.io/github/StoDevX/AAO-React-Native)

## About
The St. Olaf community, now in pocket size… rewritten in React Native.

## Download
- [Android](https://play.google.com/store/apps/details?id=com.allaboutolaf)
- [iOS](https://itunes.apple.com/us/app/all-about-olaf/id938588319)

## Getting Started
- Clone the repository
- `cd` into the folder
- [Install React Native](http://facebook.github.io/react-native/docs/getting-started.html#content)
- `npm install`
- `npm run ios`

## Note
The Calendar might nag you for a Google Calendar API key. You can either ask someone involved with this project for a key, or you may [create one yourself](https://console.developers.google.com/projectselector/apis/credentials) for use during development.

1. Create a copy of the `.env.sample.js` file and rename it to `.env.js`
2. Insert your API key in place of the `key goes here` text

## Todo
* Bugs! All bugs should have the [`bug`](https://github.com/StoDevX/AAO-React-Native/issues?q=is%3Aopen+is%3Aissue+label%3Abug) label in the issues
* Enhancements! All ideas for improvement that are not being worked on should be [`closed` and labelled as `discussion`](https://github.com/StoDevX/AAO-React-Native/issues?utf8=%E2%9C%93&q=is%3Aclosed%20is%3Aissue%20label%3Adiscussion)
* [3D touch actions](https://github.com/jordanbyron/react-native-quick-actions) for icon and within
* [Touch-ID](https://github.com/naoufal/react-native-touch-id) for SIS

## Contributing
Would you like to contribute? Great! Have a look at [React Native](http://facebook.github.io/react-native/docs/getting-started.html) and make a pull request! PRs are required, so fork away and make one! If you feel like you should have write access to the repo, please make an issue and we can discuss it.

If you are looking to get a start with the project, issues tagged with all 3 [`good first change`, `discussion`, and `closed`](https://github.com/StoDevX/AAO-React-Native/issues?q=is%3Aissue+is%3Aclosed+label%3Adiscussion+label%3A%22good+first+change%22) are a great place to start. These issues are ones that the team has identified as simple, small changes that won't get too deep, and will be easy to approve for merging. See our [todo](https://github.com/StoDevX/AAO-React-Native#todo) section if you are curious why they are tagged as `closed`. They really are open!

We use two continuous-integration (CI) systems to make sure that the project still works as we change things. Any submissions you make will be validated by [Travis](https://travis-ci.org/StoDevX/AAO-React-Native/builds) and [CircleCI](https://circleci.com/gh/StoDevX/AAO-React-Native).

Before you commit and push, make sure to lint your changes and fix any errors or warnings that `npm run lint` shows. We try to keep the `master` branch clean of all messages from eslint.

As always, please keep the [Code of Conduct](https://github.com/StoDevX/AAO-React-Native/blob/master/CodeOfConduct.md) in mind.

repository: chantysothy/AAO-React-Native

repo_name: chantysothy/AAO-React-Native


text:
# Doxygen Dark Theme

Theme inspired by the Dark+ theme in the Visual Studio Code editor.

The theme based on Tilen Majerles project on the MIT Licence.
[MaJerle/doxygen-dark-theme](https://github.com/MaJerle/doxygen-dark-theme)

## Preview
See example: [DEMO (maatiug/Minesweeper)](https://goorkamateusz.github.io/Minesweeper/)

![img](doc/example1.jpg)

## How to change doxygen theme

Just modify 4 lines of doxygen config file (default Doxfile):

```
HTML_EXTRA_STYLESHEET  = "<path>/custom.css"
```

```
HTML_HEADER            = "<path>/html_header.html"
HTML_FOOTER            = "<path>/html_footer.html"
```

```
HTML_EXTRA_FILES       = "<path>/custom.js"
```

repository: goorkamateusz/doxygen-vscode-theme

repo_name: goorkamateusz/doxygen-vscode-theme


text:
See [upstream prow](https://github.com/kubernetes/test-infra/tree/master/prow) documentation for more detailed and generic information about what prow is and how it works.

## Onboarding

If you are onboarding your GitHub organization or repository to be served by the OSS Prow instance, please see the [onboarding guide](./onboarding.md).

## Upgrading Prow

*Note*: oss prow is now automatically updated on a daily basis, see [Autobump
PRs](https://github.com/GoogleCloudPlatform/oss-test-infra/search?q=author%3Agoogle-oss-robot+is%3Apr+sort%3Aupdated+head%3Aautobump-oss-prow&type=Issues)
for ongoing/histories. This is configured as
[`ci-oss-test-infra-autobump-prow`](https://github.com/GoogleCloudPlatform/oss-test-infra/blob/49cc9a1bff81427ea8f10b9625269be7a9cf3ae0/prow/prowjobs/GoogleCloudPlatform/oss-test-infra/gcp-oss-test-infra-config.yaml#L335)
job.

Please check recent [prow announcements](https://github.com/kubernetes/test-infra/tree/master/prow#announcements) before updating, if you are not already familiar with them.

```shell
prow/bump.sh --auto
# commit change and merge PR
make -C prow/oss deploy
# kubectl get pods and watch for problems
# https://oss.gprow.dev and watch for problems
# Look at stack driver logs (go/oss-prow-debug or whatever) and look for problems)
```

### Watch pods

```console
$ watch kubectl get pods

Every 2.0s: kubectl get pods                                                                                Fri Aug 11 15:40:31 2017

NAME                         READY     STATUS    RESTARTS   AGE
deck-3621325446-00drl        1/1       Running   0          54m
deck-3621325446-9pdqw        1/1       Running   0          55m
deck-3621325446-njnwk        1/1       Running   0          54m
hook-3348033068-2tdd3        1/1       Running   0          45m
hook-3348033068-x99bf        1/1       Running   0          45m
horologium-617344823-js4mk   1/1       Running   0          50m
plank-302445171-92rfx        1/1       Running   0          41m
sinker-799599164-z44wj       1/1       Running   0          34m
tot-763621987-pktpj          1/1       Running   0          37m
```

### Check logs

```bash
kubectl logs -l app=deck # or the appropriate label like app=hook
# or a specific pod: kubectl logs deck-3621325446-00drl
```

## Creating a Job on Your Repo

### Github Trigger

The most common pattern is to trigger a job on some sort of Github event, esp. on PRs and on PR merges. Prow has concepts for these two specific stages. The first, running jobs on a PR, is called a presubmit job. The second, running jobs after the PR is merged, is called a postsubmit.

Both of these types of jobs can be configured using the config configmap [here](./config.yaml). In the configmap, you are configuring on which repo to run a particular job, basic metadata like the name, and then the build image. For these to be triggered, you must add `trigger` to the list of plugins in the plugins configmap [here](./plugins.yaml). For example, to add a simple presubmit to `my-repo`, requires the following edits:

```yaml
# in config.yaml
triggers:
- repos:
  - istio/istio
  - istio/test-infra
  - istio/<my-repo> # ADD THIS LINE
# ...
presubmits:
  # ...
  istio/<my-repo>: # ADD THIS BLOCK
  - name: my-repo-presubmit
    context: prow/my-repo-presubmit.sh
    always_run: true
    rerun_command: "@istio-testing test this"
    trigger: "@istio-testing test this"
    branches:
    - master
    spec:
      containers:
      - image: gcr.io/istio-testing/prowbazel:0.4.11
    # ...

# in plugins.yaml
my-repo: # ADD THIS BLOCK
- trigger
```

### Manually Trigger a Prow Job

```bash
# Assuming you cannot click the rerun button on deck
# and if you are oncall, do the following:
go get -u k8s.io/test-infra/prow/cmd/mkpj

mkpj --job=FOO > ~/foo.yaml # and answer interactive questions

# Contact #oncall to ensure you are approved to do the following:
kubectl --context=oss-prow create -f ~/foo.yaml
```

## Prow Secrets

Some of the prow secrets are managed by kubernetes external secrets, which
allows prow cluster creating secrets based on values from google secret manager
(Not necessarily the same GCP project where prow is located). See more detailed
instruction at [Prow Secret](https://github.com/kubernetes/test-infra/blob/master/prow/prow_secrets.md).

repository: GoogleCloudPlatform/oss-test-infra

gha_language: Jupyter Notebook

repo_name: GoogleCloudPlatform/oss-test-infra


text:
---
title: New Version 1.6.0
author: Kamata Ryo
authorURL: http://twitter.com/kamataryo_
---

# jqf New minor version released!

![hello! new version!](/img/2020-04-14/01.jpg)

Yeah<EMAIL_ADDRESS>supports default function string argument of `'x => x'`.

In other word, `jqf` has been equivalent with `jqf 'x => x'`.

```
$ echo '{"hello":"world"}' | jqf
{
  "hello": "world"
}
```

We can use the `jqf` as a simplest JSON formatter!

repository: kamataryo/jqf

repo_name: kamataryo/jqf


text:
# @tippy.js/react

React component for [Tippy.js](https://github.com/atomiks/tippyjs) 3.

## Installation

```
npm i @tippy.js/react
```

CDN<EMAIL_ADDRESS>
Requires React 16.2+, `prop-types`, and `tippy.js` if using via CDN.

## Usage

Import the Tippy component and Tippy's CSS.

Required: tooltip content as `props.content` and a single element child (reference) as `props.children`.

```jsx
import React from 'react'
import ReactDOM from 'react-dom'
import Tippy from<EMAIL_ADDRESS>import 'tippy.js/dist/tippy.css'

const RegularTooltip = () => (
  <Tippy content="Hello">
    <button>My button</button>
  </Tippy>
)

const TooltipWithJSX = () => (
  <Tippy content={<span>Tooltip</span>}>
    <button>My button</button>
  </Tippy>
)

const TooltipWithProps = () => (
  <Tippy content="Hi" arrow={true} duration={500} delay={[100, 50]}>
    <button>My button</button>
  </Tippy>
)

const App = () => (
  <main>
    <RegularTooltip />
    <TooltipWithJSX />
    <TooltipWithProps />
  </main>
)

ReactDOM.render(<App />, document.getElementById('root'))
```

## Native props

See the [Tippy.js docs](https://atomiks.github.io/tippyjs/#all-options)

## React-specific props

### `isEnabled?: boolean`

Prop to control the `tippy.enable()` / `tippy.disable()` instance methods. Use this when you want to temporarily disable a tippy from showing.

```jsx
class App extends Component {
  state = {
    isEnabled: true
  }

  render() {
    return (
      <Tippy content="test" isEnabled={this.state.isEnabled}>
        <button />
      </Tippy>
    )
  }
}
```

### `isVisible?: boolean`

Prop to control the `tippy.show()` / `tippy.hide()` instance methods. Use this when you want to programmatically show or hide the tippy instead of relying on UI events.

⚠ **It must be accompanied by a `"manual"` trigger prop.**

```jsx
class App extends Component {
  state = {
    isVisible: true
  }

  render() {
    return (
      <Tippy content="test" trigger="manual" isVisible={this.state.isVisible}>
        <button />
      </Tippy>
    )
  }
}
```

> **Note 1**: You should also set the `hideOnClick` prop to `false` if you don't want the tippy to hide when the user clicks on the document somewhere.

> **Note 2**: Use this prop instead of Tippy's native `showOnInit` prop. The native prop just shows the tippy on init but won't respond to prop changes.

### `onCreate?: (tip: Instance) => void`

Callback invoked when the Tippy instance has been created. Use this when you need to store the Tippy instance on the component.

```jsx
class App extends Component {
  storeTippyInstance = tip => {
    this.tip = tip
  }

  render() {
    return (
      <Tippy content="test" onCreate={this.storeTippyInstance}>
        <button />
      </Tippy>
    )
  }
}
```

## Default props

You can create a new component file that imports the component and sets the default props. From this file, you can import the component throughout your app.

```js
import Tippy from<EMAIL_ADDRESS>
// `performance: true` disables data-tippy-* attributes as they are unnecessary
// in React and slow down initialization.
Tippy.defaultProps = {
  performance: true
}

export default Tippy

// In another file
import Tippy from './Tippy'
```

As an example, you might want to distinguish between a tooltip and a popover by creating a separate component for both.

```jsx
export const Tooltip = ({ children, ...rest }) => (
  <Tippy {...rest}>{children}</Tippy>
)
Tooltip.defaultProps = {
  animation: 'fade',
  arrow: true,
  delay: 150,
  theme: 'translucent'
}

export const Popover = ({ children, ...rest }) => (
  <Tippy {...rest}>{children}</Tippy>
)
Popover.defaultProps = {
  animateFill: false,
  animation: 'scale',
  interactive: true,
  interactiveBorder: 10,
  theme: 'light-border',
  trigger: 'click'
}

// In another file
import { Tooltip, Popover } from './Tippy'
```

## License

MIT

repository: genny-project/keycloak-themes

repo_name: genny-project/keycloak-themes


text:
<!--
#
# Copyright (c) 2013, Xin YUAN, courses of Zhejiang University
# All rights reserved.
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the 2-Clause BSD License.
#
# Author contact information:
#<EMAIL_ADDRESS>#
-->

# GKC

General Kind C++

## Source Code

1. Use one of the *.UTF8 locales for Linux system.
1. The source code files are encoded as UTF8 with BOM.
1. All constant strings with CharA type should be considered as UTF8 encoding.
1. All constant wide strings and global data with multi-byte types are stored as compiling machine endian in assemblies.

## Production

Install the necessary softwares in the production machine.
Assume the building directory has the same level of directory `GKC`.

### Preparation

#### Windows

##### Compiler

Build Tools for Visual Studio 2022 without ATL, MFC and C++/CLI.

##### Latex

Install MikTex, and use TexWorks. Install other packages through Maintenance UI such as CJK packages.
Two patterns, `pdfLaTeX+MakeIndex+BibTeX` and `XeLaTeX+MakeIndex+BibTeX` with 'xeCJK' can be used
for composing papers, books and slides.

#### Linux

##### Compiler

1. Install g++

	g++-4.9

	```
	sudo apt-get install build-essential
	```

	manual documents

	```
	sudo apt-get install glibc-doc
	sudo apt-get install manpages-posix-dev
	```

1. Install libuuid:

	```
	sudo apt-get install uuid-dev
	```

##### Latex

1. Install TexLive:

	```
	sudo apt-get install texlive-full
	```

1. Install fonts:

	```
	sudo apt-get install ttf-mscorefonts-installer
	sudo apt-get install xfonts-wqy ttf-wqy-microhei ttf-wqy-zenhei
	fc-cache
	fc-list
	```

1. Install TexStudio:

	Install TexStudio.

	Select the menu `Options->Configure Texstudio->Commands`,
change the item `XeLaTeX` to:

	```
	xelatex -synctex=1 -interaction=nonstopmode %.tex
	```

	Select the menu `Options->Configure Texstudio->Build`,
change the item `Default Compiler` to `XeLaTeX`.

### Testing

#### Windows

1. CMake:
	* x86 machine:

		```
		cmake ../GKC -G "Visual Studio 17 2022" -A Win32
		```

	* x64 machine:

		```
		cmake ../GKC -DUSE_64BITS=1 -G "Visual Studio 17 2022" -A x64
		```

1. make:

	```
	MSBuild ALL_BUILD.vcxproj /t:build /p:Configuration=Debug
	```

1. test:

	```
	cd test
	ctest -C "Debug"
	```

#### Linux

1. CMake:
	* x86 machine:

		```
		cmake ../GKC -DCMAKE_BUILD_TYPE=Debug -G "Unix Makefiles"
		```

	* x64 machine:

		```
		cmake ../GKC -DCMAKE_BUILD_TYPE=Debug -DUSE_64BITS=1 -G "Unix Makefiles"
		```

1. make:

	```
	make
	```

1. test:

	```
	cd test
	ctest
	```

### Release

#### Windows

1. CMake:
	* x86 machine:

		```
		cmake ../GKC -G "Visual Studio 17 2022" -A Win32
		```

	* x64 machine:

		```
		cmake ../GKC -DUSE_64BITS=1 -G "Visual Studio 17 2022" -A x64
		```

1. make:

	```
	MSBuild ALL_BUILD.vcxproj /t:build /p:Configuration=Release
	```

1. pack:

	```
	cpack -D CPACK_GENERATOR="ZIP;TGZ"
	```

	Compress the files, setup-gkc.vbs, uninstall-gkc.vbs and GKC-1.0.1-win32.zip (or GKC-1.0.1-win64.zip),
into a zip file and redistribute it.

	Pack with debug version:

	```
	cpack -C "Debug" -D CPACK_GENERATOR="ZIP;TGZ"
	```

#### Linux

1. CMake:
	* x86 machine:

		```
		cmake ../GKC -DCMAKE_BUILD_TYPE=Release -G "Unix Makefiles"
		```

	* x64 machine:

		```
		cmake ../GKC -DCMAKE_BUILD_TYPE=Release -DUSE_64BITS=1 -G "Unix Makefiles"
		```

1. make:

	```
	make
	```

1. pack:

	```
	cpack
	```

	Compress the files, setup-gkc.sh, uninstall-gkc.sh, GKC-1.0.1-Linux.sh and GKC-1.0.1-Linux.tar.gz,
into a zip file and redistribute it.

### Pack for cpkg system

dev:

```
cpkg-info.txt (from cpkg-info.dev)
cpkg-import.cmk
LICENSE
common.cmk
ftsc.cmk
bin/
	generated executable files (exclude test programs)
include/
	<SOURCE>/public/include/* <SOURCE>/RT/GkcSys/public->sys <SOURCE>/RT/GkcCompiler/public->compiler <SOURCE>/RT/GkcParser/public->parser
lib/
	generated library files (lib)
licenses/
	<SOURCE>/licenses/*
scripts/
	<SOURCE>/scripts/linux/* (only for linux)
```

rt:

```
cpkg-info.txt (from cpkg-info.rt)
LICENSE
lib/
	generated library files (dll, so)
```

repository: ZJUGKC/GKC

repo_name: ZJUGKC/GKC


text:
apps-ios-dyn-resource
=====================

Dynamic resource - reads what to present from a file which can be altered by scripts

Notes:

- It's "product name" is not the same as it's build scheme name


text:
# Laravel 5 Installation script(for debian distros)
This script checks for the basic requirements and then install the fresh copy of laravel

## What it actually does
- Installs apache, php5, mysql if not already installed
- Installs phpmyadmin
- Checks if php is installed
- Checks if php version is above the requirement for laravel installation
- Checks if the required php extensions are enabled
- Checks and installs composer if not installed
- Install a fresh copy of laravel
- Set needed permissions for files and folders of laravel
- Create a .env file from the .env.example file
- generates application key

## What to do
Run this script with root permission (like 'sudo' in debian distros) from anywhere.


text:
# mujoco-maze
[![Actions Status](https://github.com/kngwyu/mujoco-maze/workflows/CI/badge.svg)](https://github.com/kngwyu/mujoco-maze/actions)
[![PyPI version](https://img.shields.io/pypi/v/mujoco-maze?style=flat-square)](https://pypi.org/project/mujoco-maze/)
[![Black](https://img.shields.io/badge/code%20style-black-000.svg)](https://github.com/psf/black)

Some maze environments for reinforcement learning (RL) based on [mujoco-py]
and [openai gym][gym].

Thankfully, this project is based on the code from  [rllab] and
[tensorflow/models][models].

Note that [d4rl][d4rl] and [dm_control][dm_control] have similar maze
environments, and you can also check them.
But, if you want more customizable or minimal one, I recommend this.

## Usage

Importing `mujoco_maze` registers environments and environments listed
below are available via `gym.make`.

E.g.,:
```python
import gym
import mujoco_maze  # noqa
env = gym.make("Ant4Rooms-v0")
```

## Environments

- PointUMaze/AntUmaze

  ![PointUMaze](./screenshots/PointUMaze.png)
  - PointUMaze-v0/AntUMaze-v0 (Distance-based Reward)
  - PointUmaze-v1/AntUMaze-v1 (Goal-based Reward i.e., 1.0 or -ε)

- Point4Rooms/Ant4Rooms

  ![Point4Rooms](./screenshots/Point4Rooms.png)
  - Point4Rooms-v0/Ant4Rooms-v0 (Distance-based Reward)
  - Point4Rooms-v1/Ant4Rooms-v1 (Goal-based Reward)
  - Point4Rooms-v2/Ant4Rooms-v2 (Multiple Goals (0.5 pt or 1.0 pt))

- PointPush/AntPush

  ![PointPush](./screenshots/AntPush.png)
  - PointPush-v0/AntPush-v0 (Distance-based Reward)
  - PointPush-v1/AntPush-v1 (Goal-based Reward)

- PointFall/AntFall

  ![PointFall](./screenshots/AntFall.png)
  - PointFall-v0/AntFall-v0 (Distance-based Reward)
  - PointFall-v1/AntFall-v1 (Goal-based Reward)

- PointBilliard

  ![PointBilliard](./screenshots/PointBilliard.png)
  - PointBilliard-v0 (Distance-based Reward)
  - PointBilliard-v1 (Goal-based Reward)
  - PointBilliard-v2 (Multiple Goals (0.5 pt or 1.0 pt))

## Customize Environments
You can define your own task by using components in `maze_task.py`,
like:

```python
import gym
import numpy as np
from mujoco_maze.maze_env_utils import MazeCell
from mujoco_maze.maze_task import MazeGoal, MazeTask
from mujoco_maze.point import PointEnv

class GoalRewardEMaze(MazeTask):
    REWARD_THRESHOLD: float = 0.9
    PENALTY: float = -0.0001

    def __init__(self, scale):
        super().__init__(scale)
        self.goals = [MazeGoal(np.array([0.0, 4.0]) * scale)]

    def reward(self, obs):
        return 1.0 if self.termination(obs) else self.PENALTY

    @staticmethod
    def create_maze():
        E, B, R = MazeCell.EMPTY, MazeCell.BLOCK, MazeCell.ROBOT
        return [
            [B, B, B, B, B],
            [B, R, E, E, B],
            [B, B, B, E, B],
            [B, E, E, E, B],
            [B, B, B, E, B],
            [B, E, E, E, B],
            [B, B, B, B, B],
        ]

gym.envs.register(
    id="PointEMaze-v0",
    entry_point="mujoco_maze.maze_env:MazeEnv",
    kwargs=dict(
        model_cls=PointEnv,
        maze_task=GoalRewardEMaze,
        maze_size_scaling=GoalRewardEMaze.MAZE_SIZE_SCALING.point,
        inner_reward_scaling=GoalRewardEMaze.INNER_REWARD_SCALING,
    )
)
```
You can also customize models. See `point.py` or so.

## Warning
This project has some other environments (e.g., reacher and swimmer)
but if they are not on README, they are work in progress and
not tested well.

## License
This project is licensed under Apache License, Version 2.0
([LICENSE-APACHE](LICENSE) or http://www.apache.org/licenses/LICENSE-2.0).

[d4rl]: https://github.com/rail-berkeley/d4rl
[dm_control]: https://github.com/deepmind/dm_control
[gym]: https://github.com/openai/gym
[models]: https://github.com/tensorflow/models/tree/master/research/efficient-hrl
[mujoco-py]: https://github.com/openai/mujoco-py
[rllab]: https://github.com/rll/rllab

repository: TakuyaHiraoka/mujoco-maze

repo_name: TakuyaHiraoka/mujoco-maze


text:
# Rails Apps Notes

Rails can be used to create a variety of wep applications from simple JSON based API to a complete multi-page web application. It also has built-in support for various client-side frameworks.

## API

The `rails`' `new` command can be used to generate an application designed as an API server.

```sh
rails new {app_name} --api [--database={database}]
# {database} is one of: mysql, postgresql, sqlite3, etc
```

See `rails new --help` and/or https://guides.rubyonrails.org/api_app.html.

repository: dhurlburtusa/shortcuts

repo_name: dhurlburtusa/shortcuts


text:
---
title: Plugins overview
tags: [plugins]
keywords: plugin, overview, plugins
permalink: mydoc_plugin_overview.html
sidebar: mydoc_sidebar
folder: mydoc
---
{% include important.html content="Work in progress!" %}
{% include warning.html content="Some plugin documentation pages are outdated!" %}
Plugins are sets of stages and other pieces of code that plug into the CodeFeedr system. The CodeFeedr
repository contains a bunch of plugins already. All of them provide stages, and the MongoDB plugin
also provides a key manager.

To use a plugin, simply add the project as a dependency in your SBT build file.

### What a plugin looks like

A plugin is a simple Scala project without a main class. It must depend on `codefeedr-core`. The CodeFeedr
project has put its plugins in the `org.codefeedr.plugins` package, and their stages into a `stages`
subpackage. This is not required.

### Creating a plugin
See [this](/mydoc_your_own_plugin.html) page.

repository: codefeedr/codefeedr

branch_name: refs/heads/develop

gha_language: Scala

repo_name: codefeedr/codefeedr


text:
### v1.1.9 (06/20/2017)

- allow additional options to be passed in to middleware method (https://github.com/krakenjs/makara-amdify/pull/12)

### v1.1.8

* REFACTOR: to use makara-builder@2. See: https://github.com/krakenjs/makara-builder/blob/v2.x/README.md#api and https://github.com/krakenjs/makara-builder/blob/v2.x/CHANGELOG.md#v200

### v1.1.7

* FIX: upgrade glob module to ^7 to address vulnerability in minimatch. https://github.com/jpillora/node-glob-all/issues/12

repository: datamass-io/ml-kraken-models

repo_name: datamass-io/ml-kraken-models


text:
meta-kleistpark
===============

This README file contains information on the contents of the
kleistpark layer.

Please see the corresponding sections below for details.

Dependencies
------------

This layer depends on:

  URI: git://git.yoctoproject.org/poky.git

  branch: dylan

Patches
-------

Please submit any patches against the kleistpark layer to the
DirectFB developers<EMAIL_ADDRESS>with subject "[meta-kleistpark]".

Adding the kleistpark layer to your build
--------------------------------------------

In order to use this layer, you need to make the build system aware of
it.

Assuming the kleistpark layer exists at the top-level of your
yocto build tree, you can add it to the build system by adding the
location of the kleistpark layer to bblayers.conf, along with any
other layers needed. e.g.:

  BBLAYERS ?= " \
    /path/to/yocto/meta \
    /path/to/yocto/meta-yocto \
    /path/to/yocto/meta-yocto-bsp \
    /path/to/yocto/meta-kleistpark \
    "

Available images
----------------
* kleistpark-image

repository: gongfuPanada/meta-kleistpark

repo_name: gongfuPanada/meta-kleistpark