text:
# Object Oriented  Programming - DT-228/2
## Assignment 1 Semester 1 2016

[![YouTube](http://i.imgur.com/sdjvFzI.jpg)](https://www.youtube.com/watch?v=DhkGO3F-yLo)

### Overview
This program is desgined to look like an operating system for a spaceship.
There is ambient noise playing a loop in the background.
I used the processing sound library and ControlP5.

It has 7 window states

- Login
- Transition
- Report Summary
- Star Map
- Local solar system
- Ship controls
- Probes

### Login

This page is shown when the system is locked. It has preset text in the login credentials and won't
let you through to any other screen until the login button has been pressed. If you click a menu option when it
is locked an error sound will play and the login menu will flash.
![Sketch](http://i.imgur.com/sdjvFzI.jpg)

### Transition

This handles the loading screen. It fades the login screen out, fades the rotating logo in.
When complete it automatically goes to Report Summary.

### Report Summary

This is a kind of landing page once you log in. A welcome message will play. It has some basic information about the senario setup
in the program, such as where you are in the universe and some systems status.
![Sketch](http://imgur.com/aR5dqcn.jpg)

### Star Map

On this page you see a star map on the left hand side. It uses the same data file we used for the lab test.
Although I have heavily edited it, I removed data I wasn't using and added more data.

The current system is listed under the grid and is marked in red on the grid.

You can select up to 36 stars in any order. They will all be connected by a line in the order you select.
The information about each star will be shown on the right hand side when it is selected. You will be able
to view 4 selections at a time, using the next page and prev page buttons.

The reset button will clear the selected stars.
![Sketch](http://imgur.com/4XEePtH.jpg)

### Local Solar System

On this page you are presented with a 3D rendering of a solar system. This solar system will always have 4 planets,
however the size of each planet, the orbit radius, the initial position and rotation speed will be randomly generated
every time the program runs.

There are two sliders for control on this page. One tilts the camera to view the solar system from different angles,
the other changes the rotation speed, or direction.

You can click any of the planets and some basic information will be shown in the box on the right.
From here you can launch a probe to the planet. The probe information can be viewed in the probe menu.
![Sketch](http://imgur.com/YZgEN2n.jpg)

### Ship Controls

Here you can control certain aspects of the ship, such as the power of the engines, the weapons and the shield.
There are sliders for each element. The values of the sliders effect the colour of the bars above.

If you put the power output too high you will get warning and flashing lights. You can also cause overheating. If the overall
power output is too high you will cause a reactor failure. This will shut everything down and won't come back online
until the program is restarted.
![Sketch](http://imgur.com/xBDmo8W.jpg)

### Probes

From this menu option you can view more data about each planet you sent a probe to in the solar system map.
Each planet with a probe on it is listed on the left side. Click them to view more data.
The data will be shown in a box on the right. Below that will be a radar.

You can scroll to zoom in to the planet, click and drag to rotate it.
![Sketch](http://imgur.com/jStTq2w.jpg)


text:
<img align="right" src="https://images.contentstack.io/v3/assets/blt36c2e63521272fdc/blt3e371eacc79a3ca4/60a5393fe2db156d00f0b8ab/400x460_DFIR_SIFT.jpg" />

# SIFT

This is a metadata repository that is primarily used for discussiosn and issue tracking.

- [cast](https://github.com/ekristen/cast) -- installer cli
- [saltstack](https://github.com/teamdfir/sift-saltstack) -- states that actually do the work
- [packer](https://github.com/teamdfir/sift-packer) -- builds machine images using the above tools
- [package-scripts](https://github.com/teamdfir/package-scripts) -- builds certain packages hosted in [SIFT PPA](https://launchpad.net/~sift)

## Supported Distros

* 20.04 Ubuntu (Focal)
* 22.04 Ubuntu (Jammy)

## Installation

[Cast](https://github.com/ekristen/cast) is the replacement to the [SIFT CLI](https://github.com/sans-dfir/sift-cli). While the SIFT CLI should continue to work it is officially deprecated as of March 1, 2023 and will no longer be guaranteed to work after that date.

You must first install the CLI tool, then you can install SIFT.

```console
sudo cast install teamdfir/sift-saltstack
```

## Cloud Providers

### AWS

These are the latest AMIs build from [sift-packer](https://github.com/sans-dfir/sift-packer)

**Note:** these are headless, as in no GUI, it installs the server variant of SIFT.

### 22.04 Jammy Images

**Coming Soon**

### 20.04 Focal Images

Built On: March 2nd, 2022

**Default User:** `sansforensics`

```
ap-northeast-1: ami-00378014d524eee9c
ap-northeast-2: ami-06408b1c23cad3f8b
ap-northeast-3: ami-0cf5998c0f77e349d
ap-southeast-1: ami-0db8ec4279e4f27ca
ap-southeast-2: ami-04c740d52b4a32959
eu-central-1: ami-06535b5a0f7d99f4c
eu-north-1: ami-049c42f0a1ea82701
eu-west-1: ami-01f1035b96448b73b
eu-west-2: ami-0407016f8aa79ea7c
eu-west-3: ami-0c444654c3cb65700
us-east-1: ami-0d52daefbb3dad017
us-east-2: ami-08faa4091f9e4121d
us-west-1: ami-0bf84579f13473e79
us-west-2: ami-0b9d5c33ff8f8ca7d
```

license: MIT

branch_name: refs/heads/master

extension: md

gha_license_id: MIT

license_type: permissive


text:
This was the 2nd meeting of WP2 on Data Policy and Stewardship.

Present:

    Florian (ELI), Gerd (PSI), Emiljana (LLB), Krysztof (EuXFEL), Jean-Francois (ILL), Jon (ESS), Dario (CERIC), Andy (ESRF)

The agenda was:

* Review of differences + similarities between Data Policies at each site

    The table of differences was reviewed but not completed. All members are invited to add their input (including observers). A column will be added to indicate which items we think need to be updated.

    A question was raised about how quickly should we open data and should subsets of data be opened to encourage opening dat sooner. What about data that the users have decided not to publish. Should they be opened earlier? How to encourage users to do so?

    The question of machine readable data was raised. What does it mean, how to include it in the data policy and how to implement it?

* Questions for FairsFair kickoff meeting

    The questions for the FAIRsFAIR meeting were reviewed. The questions can be found in this issue:

    https://github.com/panosc-eu/panosc/issues/34

* GOFAIR initiative

    Andy and Jean-Francois mentioned they had been contacted by the GO-FAIR (https://www.go-fair.org/) office in France to setup a GO-FAIR initiative for photons and neutrons. It was not clear what the advantages of this initiative are compared to working with FAIRsFAIR and working inside PaNSOC. Jean-Francois thought the political aspect was important and needed to be evaluated. Andy said the EC has asked us to work with FAIRsFAIR. Krysztof said we must all go together if we go and not as individuals.

* AOB

    Gerd mentioned that PSI is conducting a survey of data policies as part of Calipsoplus.

url: https://raw.githubusercontent.com/panosc-eu/panosc/4f061e883227a3f233bc6a456f2dde53a11376c4/Work Packages/WP2 Data Policy and stewardship/Meetings/2019-03-06/2019-03-06-WP2_Summary.md

repository: panosc-eu/panosc

gha_language: HTML

repo_name: panosc-eu/panosc


text:
# Pet Society
## CS2102 AY20/21 S1 Team25
A three-tier architecture of a Web-based database application using PostgreSQL, NodeJS for backend and Bootstrap for styling at frontend.

### Pet Lovers:

1. Ong Bik Jeun
2. Ooi Jun Hao
3. Wang Ziyue
4. Gu Yuntian
5. Wan Shi Jie, Brendan

### License & Copyright
Licensed under the [MIT LICENSE](LICENSE).

repository: BikJeun/Pet-Society

repo_name: BikJeun/Pet-Society


text:
# Pay Down Calc
[Pay Down Calc](http://paydowncalc.com)
 is an open source extra-payment mortgage calculator with charts and graphs. It has a native (not quite as capable) Android version too.

## Live Demo Web
http://PayDownCalc.com/

![Pay Down Calc screenshot for web](paydowncalcscreenshot.png)

## Build Instructions - Web

The web version of Pay Down Calc was written entirely in JavaScript --just clone drop in to a web site and go. It connects to the Google Chart engine to provide the graphs.

### Features

- Annual, Monthly, One-time extra payments
- Saved time and money
- Refinance Estimates
- Cookies to remember sessions
- Estimated PMI

## Live Demo Android

Note that this app is no longer being maintained.

https://play.google.com/store/apps/details?id=com.paydowncalc.app

![screenshot for Android](nexus4screenshot2.png)

## Build Instructions - Android

The Android version of Pay Down Calc was written in Java. It uses AChartEngine to generate its graphs. It performs everything offline without any permissions.

### Features

- Annual, Monthly, One-time extra payments
- Saved time and money

repository: EricSeokgon/PayDownCalc

repo_name: EricSeokgon/PayDownCalc


text:
# Intuitionistic Type Theory

<!-- TOC -->

- [Preamble](#preamble)
- [Contents](#contents)
- [Design](#design)
- [Type theory](#type-theory)
  - [0 type](#0-type)
  - [1 type](#1-type)
  - [2 type](#2-type)
  - [Σ type](#σ-type)
  - [Π type](#π-type)
  - [Identity type](#identity-type)
- [Inductive types](#inductive-types)

<!-- /TOC -->

## Preamble

Martin-Löf Type Theory (MLTT), Constructive Type Theory (CTT), and Intuitionistic Type Theory (ITT) are synonymous terms.

There is not one concrete theory, or even a few, but many variants, differing in a set of supported features, but all related in the fact that they are constructive (i.e. intuitionistic) approaches to type theory.

Moreover, Martin-Lof himself has published many papers, some introducing new type theories, some correcting versions of the previously published ones, e.g. after Girard showed a paritcular version of MLTT (with type-in-type) inconsistent, Martin-Löf has published a revised and improved version.

So, MLTT, CTT and ITT are the names that refer to the same family of type theories that all agree on this foundational aspect (that is, constructivism), leaving other, more or less equally important, aspects underdefined.

# Martin Lof type theory

https://en.wikipedia.org/wiki/Martin-Lof_Type_Theory
https://en.wikipedia.org/wiki/Intuitionistic_type_theory

Intuitionistic type theory is a type theory and an alternative foundation of mathematics.

Intuitionistic type theory was created by Per Martin-Löf, a Swedish mathematician and philosopher, who first published it in 1972.

There are multiple versions of the MLTT - Martin-Löf proposed both its intensional and extensional variants. Early on, he considered impredicative versions, but switched to predicative versions when Girard proved them inconsistent (affected by the Girard's paradox). However, all versions of Martin-Löf type theories keep the basic core design, using constructive logic and dependent types.

## Contents

- Design
- Type theory
  - 0 type
  - 1 type
  - 2 type
  - Σ type
  - Π type
  - Identity type
  - Inductive types
  - Universe types
- Judgements
- Categorical models of type theory
- Extensional versus intensional
- Implementations of type theory
- Martin-Löf type theories

## Design

Martin-Löf designed the type theory on the principles of mathematical constructivism. Constructivism requires that proofs contain a witnessing element, or a term that serves as evidince or justification for the proven proposition.

Since propositions are treated as types, a proven proposition must be an inhabited type, so it contains at least one term (element, value) that can witness the proven fact (represent the proof, serve as evidence).

This, constructive, approach to math does not recognize proofs - especially existential proofs - that cannot produce a witness. For example, a proof of the proposition "there exists a prime greater than 1000" must identify a specific number that is both prime and greater than 1000.

In TT, sigma type may be used to convey such information, since the terms of a sigma type are pairs: a witness (as the first component) and the conditions that a witness must satisfy (in the second component), with the second depending on the value of the first component. In general, sigma type are used to represent existential propositions, while pi types are used to represent universal propositions.

ITT accomplished this design goal by internalizing the *BHK interpretation*. An interesting consequence is that proofs become mathematical objects that can be manipulated, examined, compared.

Type constructors in ITT were built to follow a one-to-one correspondence with logical connectives (e.g. implication, `A ⇒ B`, corresponds to the type of a function, `A → B`). This is known as the Curry-Howard isomorphism (CHI). Previous type theories had also followed this correspondence, but Martin-Löf's theories were the first to extend it to predicate logic, which he achieved by introducing dependent types. Sigma types can express existential, and pi types universal quantification.

## Type theory

ITT has 3 finite types, which are composed using 5 type ctors.

Unlike set theories, type theories are not built on top of a logic (like Frege's, i.e. predicate logic). Each feature of type theory doubles in duty as a feature of both math and logic.

Types contain terms (similarly to how sets contain elements), however, unlike in set theory, an element (term) can only belong to one type.

Some terms are judgementally equal - two terms of a particular type are compared as equal according to the definition of that type. However, not all terms of a type can be compared like this. For example, if a data type is defined by recursing on the first argument (as opposed to the second of two args), that definition may yield equality such as `0 + x = x`, but not its commutative version, `x + 0 = x`. In order to also get that equallity, we need to prove commutativity (in this case). There is also the notion of computational equality, where terms like `2 + 2` and `2 ⨯ 2` compute to the canonical forms `4`, and thus are deemed computationally equal.

There are 3 finite types:
- `𝟘` type contains no terms (it is uninhabited)
- `𝟙` type contains 1 canonical term
- `𝟚` type contains 2 canonical terms

### 0 type

Because the 0 type contains 0 terms, it is also called the empty type. It is used to represent anything that cannot exist. It may be denoted by `𝟘` or `⊥`. It is used to represent a proposition that has no proof (anything unprovable, a proof that cannot exist). Because of this, *propositional negation* is usually defined as a function from any type to the empty type, `¬A := A → ⊥`.

Unlike the usual logical negation that returns a Boolean value, propositional negation instead returns a type that corresponds to the Boolean value. Usually Boolean 'false' value is represnted by the empty type, while 'true' by the unit type (see below).

### 1 type

The 1-type is known as the unit type and denoted by `𝟙` or `⊤`, while its sole canonical element is usually called "star" and so denoted by `*` or `★`.

The 1-type represents the existence of a proof - its term means that a proof exists, but the proof is not specified (and cannot be specified using only the unit type). It just represents propositions that can be proven.

### 2 type

The 2-type contains 2 canonical terms, often denoted by `tt` and `ff`.

The 2-type represents a definite choice between two values. The 2-type is used for Boolean values but not propositions. Propositions are considered the 1-type, or, if shown to not be provabl, then they have 0-type. A proposition may not be proven either way since ITT does not recognize the law of excluded middle.

### Σ type

Σ-types generalize binary (Cartesian) products.

Σ-types can encode existential quantification.

As a special, non-dependent case, Σ-type can be used to express the Cartesian product, `A×B`, of two other types (logically, such a pair would hold a proof of A and a proof of B, so one may see such a type written as 'A ∧ B').

Σ-types contain dependent (ordered) pairs where the second component of the pair dependes on the *value* of the first component.

For example, the first component of a dependent pair contains a natural number (representing length), while the second component contains a `Vec` type parameterized by the type of reals, `ℝ`, and indexed by `ℕ`:

`Σ (n : ℕ) Vec ℝ n` or perhaps `Σ (n : ℕ), (Vec ℝ n)`

The result in the second component of a dependent pair is a *vector whose length is equal to the value `n : ℕ`* from the first component.

Using set-theory terminology, this is similar to an *indexed disjoint union* of sets.

In the case of regular ordered pairs, the type of the second component does not depend on the value of the first. Thus the *type of Cartesian product* `ℕ×ℝ` degenarates a sigma type to:

`Σ (n : ℕ) ℝ`

By nesting Σ-types, we can also build *dependently-typed tuples*, not just pairs. An example of a dependently-typed triple is two integers and a proof that the first integer is smaller than the second integer, described by:

`Σ (m : ℕ), Σ (n : ℕ), ((m < n) == true)`

or (with diff definitions) as a single sigma:

`Σ ((m : ℕ) (n : ℕ)) (m < n)`

Dependent typing allows Σ-types to serve the role of existential quantifier. The statement "there exists an `n` of type `ℕ`, such that `P(n)` holds" becomes the type of ordered pairs where the first item is the value `n` of type `N` and the second item is a proof of `P(n)`. Type of the second item (proofs of `P n`) depends on the value in the first component, i.e. on `n`. Its type would be:

`Σ (n : ℕ) P n` or `Σ (n : ℕ) P(n)`

### Π type

`Π (n : ℕ) P n` or `Π (n : ℕ) P(n)`

Π-types contain functions, they generalize function types. Like regular function types, they consist of an input type and output type. However, pi-types are more powerful than functions as output (return) type can depend on input value.

Functions in type theory are different from set theory. In set theory, you look up an argument's value in a set of ordered pairs. In type theory, the argument is substituted into a term and then a reduction is applied to the term.

For example, the type of a function that, given a natural number `n`, returns a *vector containing `n` integers* is written:

`Π (n : ℕ) (Vec ℤ n)` or just `Π (n : ℕ) Vec ℤ n`

When the output type does not depend on the input value (just on the input type, as usual), the function type is often simply written

`ℕ ⟼ ℤ`

Such Π-types correspond to logical implication. The logical proposition, `A ⟹ B`, corresponds to the type `A → B`, containing functions that take proofs of `A` and return the proofs of `B`. This type could be written more consistently

`Π (a : A) B`

where `A` is any type and `B` is a type that does not depend on `a : A`.

Π-types are also used in logic for universal quantification. The statement "for every `n : ℕ`, `P(n)`, is proven" becomes a function from `n : ℕ` to proofs of `P(n)`. Thus, given the value for `n` the function generates a proof that `P` holds for that value. The type would be

`Π (n : ℕ) B(a)` or, in general `Π (a : A) B(a)`

### Identity type

Identity types are usually denoted by `≡` (rarely by `=`).

Identity types are created from two terms. Given two terms like `2 + 2` and `2 ⋅ 2`, you can create a new type `2 + 2 ≡ 2 ⋅ 2`.

The terms of that new type represent proofs that the pair reduce to the same canonical term.

Thus, since both `2 + 2` and `2 ⋅ 2` compute to the canonical term `4`; there will be a term of the type `2 + 2 ≡ 2 ⋅ 2`.

In ITT, *the single way to make terms of identity types* is by getting the data constructor `refl` (for reflexivity) out:

`refl : Π (a : A) (a ≡ a)`

In MLTT, it is possible to create an identity type like `1 ≡ 2` where the terms do not reduce to the same canonical term, but you will be unable to create terms of that type. In fact, if you were able to create a term of `1 ≡ 2`, you could create a term of `⊥`.
Putting that into a function would generate a function of type `1 ≡ 2 → ⊥`. Since `¬A := A → ⊥` is how ITT defines negation, you would have `¬(1 ≡ 2)`, which actually amounts to `1 ≢ 2`.

*Equality of proofs* is an area of active research in proof theory and has led to the development of Homotopy Type Theory and Cubical Type Theory.

## Inductive types

https://en.wikipedia.org/wiki/Inductive_type

Inductive types allow the creation of complex, self-referential types.

For example, a linked list of natural numbers is either an empty list or a pair of a natural number and another linked list.

Inductive types can be used to define unbounded mathematical structures like trees, graphs.

In fact, the natural numbers type may be defined as an inductive type, either being `0` or the successor of another natural number.

Inductive types define new constants, such as zero `0 : ℕ` and the successor function `S : ℕ → ℕ`.

Since `S` does not have a definition and cannot be evaluated using substitution, terms like `S0` and `SSS0` become the canonical terms of the natural numbers.

Proofs on inductive types are made possible by induction. Each new inductive type comes with its own inductive rule. To prove a predicate `P` for every natural number, you use the following rule:

```agda hs
ℕ-elim : P 0 -> (Π (n : ℕ) (P n -> P (succ n))) -> Π (n : ℕ) P n

-- which is

ℕ-elim : P 0
       → (Π (n : ℕ) (P n -> P (succ n)))
       ---------------------------------
       → Π (n : ℕ) P n
```

In Agda, the recursor for the natural number type is defined as follows:

```agda hs
-- | natural number type definition
data ℕ : Set where
  zero : ℕ
  succ : ℕ → ℕ

-- | natural number type elimiation
ℕ-elim : {P : ℕ → Type}
       →            P 0
       → ((n : ℕ) → P n → P (succ n))
       ------------------------------
       → (n : ℕ)  → P n
ℕ-elim f g 0        = f
ℕ-elim f g (succ n) = g n (ℕ-elim f g n)
```

Inductive types in ITT are defined in terms of *W-types*, the type of well-founded trees.

Later work in type theory generated coinductive types, induction-recursion, and induction-induction for working on types with more obscure kinds of self-referentiality. Higher inductive types allow equality to be defined between terms.

license: Unlicense


text:
# Video Share

Video Share is a chrome plugin for downloading videos from closed Facebook groups.

Facebook closed groups don't let users download or share video content from them. It's sometimes annoying when you are browsing through meme Facebook groups, and you see a funny video that you would like to share with a friend... but you can't. Exactly that case pushed me to create the Video Share extension that lets you download or get a sharable link to any video in any closed Facebook group.

### How to use it:
https://www.youtube.com/watch?v=U4ZawItBJow

## For your information:

1. Facebook video URL expires after a few hours, and you won't be able to watch the video from that link anymore. However, you can generate a new one and share it again.

2. The extension only supports downloading videos from closed Facebook groups right now. However, I might extend the functionality to support more cases in the future.

3. If you find any bug, let me know by creating an issue in my GitHub repo. I will be happy to help you :)

gha_language: JavaScript


text:
Contributor Guidelines
===

Thank you for contributing to Nucleus! Please have a read through this document and make sure you understand it all
before contributing.

## Reporting an Issue, Requesting a Feature

When submitting an issue through GitHub Issues, please remember that we are volunteers, and as volunteers, we have
limited time to be able to help. We would love to spend as much time fixing your issues and implementing features
as possible. To that end, please keep the following in mind when reporting bugs and requesting features:

* Make the title of the report clear. "It's broken" does not help us much, "Nucleus reports an error when I try to use
/lockweather" is more helpful and lets us see what is wrong just by looking at the list.

* When reporting a bug:
    * Describe how you reproduce the bug step by step
    * Explain what you expect to happen
    * Explain what actually happens
    * Include screenshots or console output if it helps explain the issue
    (but do **not** take a screenshot of console output)

* When describing a feature:
    * Tell us what you'd like to see
    * Tell us why you want it, and what the use case is
    * Give us an idea on how it should work

* If we need more information about a bug or a feature, we'll ask for clarification! We want to get the system right.

* If we reject a suggestion, remember that Nucleus is an _essentials_ plugin, NOT "everything but the kitchen sink".
We may, however, consider writing a separate plugin as part of the Nucleus family.

For more information about writing a bug report in general, have a look at [this page](http://www.chiark.greenend.org.uk/~sgtatham/bugs.html),
particularly the summary at the bottom.

## Pull Requests

If you'd like to write code for us, great, welcome aboard! We have a few things that you should be aware of.

### Developing Nucleus.

As Nucleus is a big plugin, there are some fancy tricks involved to make the system easier to manage, including the
heavy use of annotations and auto-generation of permissions. Though it can seem intimidating at first, it's actually an easy
system if you don't have to touch the internals!

#### Creating Modules

If you are creating a new module, the following should be kept in mind:

* Create a new package with the name of the module. The name should be singular.

* If your module does not have any config involved, create a class that extends `StandardModule`, annotate it with `@ModuleData` and give it a name and id. The id should be the same as the package name. Tests enforce the use of this annotation.

* If the module has some config involved:
    * Create a class that extends `ConfigurableModule<>`, where the generic type is the `NucleusConfigAdapter` you'll create, annotate it with `@ModuleData` and give it a name and id. The id should be the same as, or similar to, the package name. Tests enforce the use of this annotation. The method you are required to extend _should_ create a new instance of the config adapter.
    * Create a new Config class that mirrors your config structure using `@ConfigSerializable` and `@Setting` annotations from Configurate.
    * Create a class that extends the `NucleusConfigAdapter` to manage this config class.
    * If you have any services that need to be registered, they can be done in the `performPreTasks` method on `StandardModule`, [see the AFK module for a good example](https://github.com/NucleusPowered/Nucleus/blob/master/src/main/java/io/github/nucleuspowered/nucleus/modules/afk/AFKModule.java).

* Put commands, listeners and runnables in sub packages - they will be registered automatically if they are of the correct base classes - see below.

For an example of adding a module with config, see [this commit for adding /commandspy and related module/listeners](https://github.com/NucleusPowered/Nucleus/commit/d31a860daef687ebeeb729c51a92cf6959daf8f1)

If you think there is a bug with the module loader itself (package, `uk.co.drnaylor.quickstart`, please file a bug on the [QuickStart Module Loader](https://github.com/NucleusPowered/QuickStartModuleLoader) pages instead.

#### Commands

If you are developing a command, please keep the following in mind:

* ALWAYS use the `AbstractCommand<>` class. It contains a lot of scaffolding that the plugin loader requires.
* If your command requires arguments, override the `CommandElement[] getArguements()` method, and return an array of arguments.
* Please add a one-line description for your command - add it to the `command.properties` file with the key
`[parentcommand alias].[primary command alias].desc`. Also consider adding an extended description, use the key `[parentcommand alias].[primary command alias].extended`.
    * The parent command alias is only required if the command is a subcommand - it is a period separated path to the sub command.
* If you require one of the Nucleus handlers/services - check to see if it can be injected, using the `@Inject` annotation, or check if it is available from the plugin object. The plugin object is always injected into a protected variable and does not need to be done again.

#### Listeners

If you are creating a listener, ensure that the listener class(es) extend the `ListenerBase` class, this will allow you to access the injected `plugin` variable. If you want something in the class to reload when the configuration is reloaded, extend the `ListenerBase.Reloadable` class instead. Other injections can be used on this class.

If your listeners are only going to fire under certain conditions that will only be altered by a configuration reload, create a static, no-arg constructor inner class that extends `Predicate<Nucleus>` which tests the conditions for whether the listener should be registered. Then, annotate your listener with `@ConditionalListener`, where the argument is the class reference to your inner class. See [the Command Spy listener](https://github.com/NucleusPowered/Nucleus/blob/sponge-api/5/src/main/java/io/github/nucleuspowered/nucleus/modules/commandspy/listeners/CommandSpyListener.java#L37) for an example of this.

#### Repeatable Tasks

Runnable Tasks extend `TaskBase` classes. They will have the Nucleus plugin instance injected automatically, but you are able to use other injections on these classes too.

The key rule here is - if you are unsure as to how something works, **please** ask us! We are more than willing to help you as much as possible!

### Code Style

We tend to follow the [Google's Java Code Conventions](https://google.github.io/styleguide/javaguide.html) but some of
the more important things to note, including changes are:

* Line endings
    * Use Unix line endings when committing (\n).
    * Windows users of git can do `git config --global core.autocrlf true` to let git convert them automatically.

* Column width
    * 150 for Javadocs
    * 150 for code
    * Feel free to wrap when it will help with readability

* Indentation
    * Use 4 spaces for indentations, do not use tabs.

* File headers
    * File headers must contain the license headers for the project as defined in HEADER.txt.
    * You can use `gradle licenseFormat` to automatically to do this for you.

* Imports
    * Imports must be grouped in the following order:
        * normal imports
        * java imports
        * javax imports

* Javadocs
    * Do not use @author
    * Wrap additional paragraphs in `<p>` and `</p>`
    * Capitalize the first letter in the descriptions within each “at clause”,
    i.e. @param name Player to affect, no periods
    * Be descriptive when explaining the purpose of the class, interface,
    enum, method etc.

* Deprecation
    * Do not deprecate content unless you have a replacement, or if the provided feature is removed.
    * Be prepared to provide justification for the deprecation.
    * When deprecating, provide the month and year when it was deprecated.

Note that this style guide is _not_ a hard and fast requirement, but please keep your code style sane and similar
to ours.

### Code Conventions
* Return `java.util.Optional<>` if you are adding an API method that could return `null`.
* Only one declaration per line.
* All uppercase letters for a constant variable. Multiple words should be separated with an underscore - `_`.

### Submitting your Pull Requests
In your PRs, please make sure you fulfil the following:

* Provide a justification for the change - is it a new feature or a fix to a bug?
    * Please note that we will reject features that are not deemed as "essential".
* Before sending a pull request ensure that your branch is up to date with the branch you are targeting. This should normally be `sponge-api/n`.
* Do not squash commits unless directed to do so, but please _rebase_ your changes on top of master when you feel your changes are ready to be submitted - _do not merge_. We will squash the commits in a way we feel logical.

repository: NucleusPowered/Nucleus

gha_language: Java

repo_name: NucleusPowered/Nucleus


text:
---
layout: post
title: "Monday 04.22.19 -  CrossFit"
teaser: "A.
 B.  "
date: 2019-04-22 00:00:00
categories: wodup
tags: wods monday
header: no
---

A.

Within 7:30:

Back Squat
– Set 1 – 20 reps  @ 60-70%
– Set 2 – 10 reps  @ 60-70%
– Set 3 – 10 reps  @ 60-70%
Rest as needed

1 Set every 2:30 minutes

B.

As Many Rounds and Reps as possible in 15 minutes:
– Run 400 meters
– 30 Air Squats
– 2 Rope Climbs 15 feet

View on WodUp

#### Compare to other Mondays
{: .t60 }

{% include list-posts tag='monday' entries='5' %}

branch_name: refs/heads/gh-pages


text:
# **James Franco**
![Image of this dude](https://images-na.ssl-images-amazon.com/images/M/MV5BMTIyOTc0MjE5NV5BMl5BanBnXkFtZTcwNjgyODQwMg@@._V1_.jpg)
### **Actor | Producer | Director**
#### Born: April 19, 1978 in Palo Alto, California, USA
Known for his breakthrough starring role on **Freaks and Geeks (1999)**, James Franco was born in Palo Alto, California on April 19, 1978.  James's mother, a writer, has occasionally acted.

## Filmology
* [Arctic Justice](http://www.imdb.com/title/tt4426464/?ref_=fn_al_tt_1)
* [Next Gen](http://www.imdb.com/title/tt0092455/)
* [Pretenders](http://www.imdb.com/title/tt0115320/)
* [The Ballad of Buster Scruggs](http://www.imdb.com/title/tt6412452/)
* [Zeroville](http://www.imdb.com/title/tt1881109/?ref_=fn_al_tt_1)
* [Blood Ride](http://www.imdb.com/title/tt6014408/?ref_=fn_al_tt_1)
* [Ozara and Katessa](http://www.imdb.com/title/tt7227516/?ref_=fn_al_tt_1)
* [The Heyday of the Insensitive Bastards](http://www.imdb.com/title/tt4076926/?ref_=fn_al_tt_1)
* [The Long Home](http://www.imdb.com/title/tt4585910/?ref_=fn_al_tt_1)
* [Future World](http://www.imdb.com/title/tt5737536/?ref_=fn_al_tt_1)

### Max's Picks
1. [Children of men](http://www.imdb.com/title/tt0206634/)
1. [Spiderman](http://www.imdb.com/title/tt0145487/)
1. [Thor](http://www.imdb.com/title/tt0800369/)
1. [Ironman](http://www.imdb.com/title/tt0371746/?ref_=nv_sr_1)

> Written with [StackEdit](https://stackedit.io/).


text:
# GitLab Copy

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

`gitlab-copy` is a simple tool for copying issues/labels/milestones/notes from one GitLab project to another, possibly running on different GitLab instances.

`gitlab-copy` won't copy anything until told **explicitely** to do so. Running it from the command line will show some stats only.

**Note**: GitLab 8.6 introduced the ability [to move an issue to another project](https://about.gitlab.com/2016/03/22/gitlab-8-6-released/), but on the same GitLab installation only. `gitlab-copy` can still prove valuable to move issues between projects on different GitLab hosts and to perform batch operations from the command line (see the feature list below).

## Download

Installing `gitlab-copy` is very easy since it comes as a static binary with no dependencies. Just [grab a compiled version](https://github.com/gotsunami/gitlab-copy/releases/latest) for your platform (or have a look to the **Compile From Source** section).

## Features

The following features are available:

- Copy milestones if not existing on target
- Copy all source labels on target (use `labelsOnly` to copy labels only, see below)
- Copy issues if not existing on target (by title)
- Apply closed status on issues, if any
- Set issue's assignee (if user exists) and milestone, if any
- Copy notes (attached to issues)
- Can specify in the config file a specific issue or range of issues to copy

## Usage

First, make sure you have valid GitLab account tokens for both source and destination GitLab installations. They are used
to access GitLab resources without authentication. GitLab private tokens are availble in "*Profile Settings* -> *Account*".

Now, write a `gitlab.yml` YAML config file to specify source and target projects, along with your GitLab account tokens:

```yaml
from:
  url: https://gitlab.mydomain.com
  token: atoken
  project: namespace/project
to:
  url: https://gitlab.myotherdomain.com
  token: anothertoken
  project: namespace/project
```

Note that a specific issue or ranges of issues can be specified in the YAML config file. If you want to
copy only issue #15 and issues #20 to #30, add an `issues` key in the `from:` key:

```yaml
from:
  url: https://gitlab.mydomain.com
  token: atoken
  project: namespace/project
  issues:
  - 15
  - 20-30
...
```

In order to copy all labels from one project to another (labels only, not issues), just append a `labelsOnly`
entry in the `from` section:

```yaml
from:
  url: https://gitlab.mydomain.com
  token: atoken
  project: namespace/project
  labelsOnly: true
to:
  url: https://gitlab.sameorotherdomain.com
  token: anothertoken
  project: namespace/otherproject
...
```

Now grab some project stats by running
```
$ ./gitlab-copy gitlab.yml
```

If everything looks good, run the same command, this time with the `-y` flag to effectively copie issues between GitLab
instances (they can be the same):
```
$ ./gitlab-copy -y gitlab.yml
```

## Compile From Source

Ensure you have a working [Go](https://www.golang.org) 1.5+ installation then install [gb](http://getgb.io) to compile the project:
```
$ go get github.com/constabulary/gb/...
```

- To build the project, just run `make`. The program gets compiled into `bin/gitlab-copy`
- Cross-compile with `make buildall`
- Prepare distribution packages with `make dist`

## License

MIT. See `LICENSE` file.

repository: zhongsihang/gitlab-copy

repo_name: zhongsihang/gitlab-copy


text:
---
summary: Point alias accounts or domains to correct XMPP user
...

Introduction
============

This module allows you to set up aliases that alert people who try to
contact them or add them to their roster what your actual JID is.  This
is useful for changing JIDs, or just in the case where you own both
example.com and example.net, and want people who contact<EMAIL_ADDRESS>to be alerted to contact you at<EMAIL_ADDRESS>instead.

This type of aliasing is well supported in the email world, but very hard
to handle with XMPP, this module sidesteps all the hard problems by just
sending the user a helpful message, requiring humans to decide what they
actually want to do.

This doesn't require any special support on other clients or servers,
just the ability to recieve messages.

Configuration
=============

Add the module to the `modules_enabled` list.

    modules_enabled = {
        ...
        "alias";
    }

Then set up your list of aliases, aliases can be full or bare JIDs,
or hosts:

    aliases = {
<EMAIL_ADDRESS>=<EMAIL_ADDRESS><EMAIL_ADDRESS>=<EMAIL_ADDRESS>        ["conference.example.com"] = "conference.example.net";
    }

You can also set up a custom response, by default it is:

    alias_response = "User $alias can be contacted at $target";

A script named mod_alias_postfixadmin.sh is included in this directory to
generate the aliases array directly from a postfixadmin MySQL database.
Instructions for use are included in the script.

Compatibility
=============

  ------- --------------
  trunk   Works
  0.10    Works
  0.9     Unknown
  0.8     Unknown
  ------- --------------

repository: chrisballinger/prosody-modules

extension: markdown

repo_name: chrisballinger/prosody-modules


text:
# Installation
> `npm install --save @types/vue-cropperjs`

# Summary
This package contains type definitions for vue-cropperjs (https://github.com/Agontuk/vue-cropperjs).

# Details
Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/vue-cropperjs.

### Additional Details
 * Last updated: Fri, 02 Jul 2021 18:05:10 GMT
 * Dependencies: [@types/vue](https://npmjs.com/package/@types/vue)
 * Global values: none

# Credits
These definitions were written by [Dylan Kidd](https://github.com/Dylkid).

repository: userderthev/gtr-academy

repo_name: userderthev/gtr-academy


text:
# Dataverse Publisher

This is an Java application that uploads (publishes) a local file to
a pre-specified dataverse destination.  Before using this application,
its user is expected to do the following dataverse(destination)-related tasks:

* create a login account on a target dataverse and generate an API-key
* create a target dataverse (and record its alias)
* create a target dataset under the above target dataverse (and record its
persistent id such as "doi:xxxxx")

## how to use
### run the "uber" jar from command prompt

    java -jar dataverse-publisher-<IP_ADDRESS>-SNAPSHOT-jar-with-dependencies.jar dataverse_url api_key dataverse_alias dataset_id file_location

### Calling the main method within a code block in Java

    String dataverse_url = "...";
    String api_key = "...";
    String dataverse_alias = "...";

    DataverseClient dvClient = new DataverseClient(dataverse_url, api_key, dataverse_alias);

    String dataset_id = "...";
    String file_location = "...";

    dvClient.publishDatafile(dataset_id, file_location);

* note: A dataverse url starts from "https://" and a dataset id exclude include "doi:"

repository: DFC-Incubator/dataverse-publisher

repo_name: DFC-Incubator/dataverse-publisher


text:
# Spicy-strips

[![Build Status](https://travis-ci.com/celer-network/celer-light-client.svg?token=DvaxasPgAzCzksHzA2ct&branch=master)](https://travis-ci.com/celer-network/celer-light-client) [![npm version](https://badge.fury.io/js/celer-light-client.svg)](https://badge.fury.io/js/celer-light-client)

This is a TypeScript implementation of a Celer client capable of sending and
receiving conditional payments via state channels. Compared to a full Celer
node, the light client does NOT have the capability of relaying payments.

## API docs

Auto-generated API docs are available [here](https://celer-network.github.io/celer-light-client/index.html).
The APIs on the client object are listed [here](https://celer-network.github.io/celer-light-client/classes/_api_celer_.celer.html).

## Try it out

1. Make sure you have MetaMask installed on your browser and you are on the
   **Ropsten** testnet.
2. Check out the repo.
3. Run `yarn install`.
4. Run `yarn demo`.
5. A demo page will be available at `localhost:1234`. It is a bare-bone static
   page that implements a simple off-chain wallet.
6. Click "Connect Celer wallet" and sign **one** pop-up message.
7. Click "Open channel", sign **one** pop-up message, sign **one** transaction,
   and sign **two** pop-up messages after the transaction is mined.

Now you are free to send payments to a recipient that has also opened a channel,
or you can send to the Celer Community OSP :)

The [code](https://github.com/celer-network/celer-light-client/blob/master/demo/demo.ts)
is pretty self-explanatory.
# Spicy-strips

repository: Jackieyewang/Spicy-strips

branch_name: refs/heads/main

repo_name: Jackieyewang/Spicy-strips


text:
# 0.10.0
- new `:merge` option on `PhxComponentHelpers.forward_assigns/2`
- `PhxComponentHelpers.extend_class/2` can now take defaults as a function

# 0.9.0
- renamed `PhxComponentHelpers.set_component_attributes/3` into `PhxComponentHelpers.set_attributes/3`
- removed `PhxComponentHelpers.set_data_attributes/3` which has been replaced by a `data: true` option passed to `PhxComponentHelpers.set_attributes/3`
- new `PhxComponentHelpers.forward_assigns/2` to pass assigns to child components

# 0.8.1
- fixed default attributes behavior

# 0.8.0
- `:into` option of `PhxComponentHelpers.extend_class/2` is renamed in `:attribute`
- `PhxComponentHelpers.extend_class/2` will overwrite input assign class with extended class
- `PhxComponentHelpers.set_form_attributes/1` will now set default form attributes when keys
exist but are nil
- `PhxComponentHelpers.set_attributes/3` and PhxComponentHelpers.set_data_attributes/3
can now take default values

# 0.7.0
- `PhxComponentHelpers.set_form_attributes/1` will now init form data with nil values
when no form/field is provided
- `PhxComponentHelpers.set_form_attributes/1` retrieves and assigns form errors
- `PhxComponentHelpers.extend_class/2` now supports new `:error_class` option to
extend CSS classes when a form field is faulty

# 0.6.0
- added `PhxViewHelpers` than can be used within templates
- added `PhxComponentHelpers.set_form_attributes/1` to fetch `Phoenix.HTML.Form` data

# 0.5.0
- all assigns are no longer prefixed by `html_` but by `raw_`
- new `:into` option is
- `set_phx_attributes/2` has a default `:into` option
- `extend_class/2` changes its signature to also use `into`

# 0.4.0
- `set_attributes/3` will set absent assigns by default
- removed `:init` option from `set_attributes/3`
- added `validate_required_attributes/2`

# 0.3.0
- New `set_prefixed_attributes/3` function that can be used to map alpinejs attributes

# 0.2.0
- Fixed issue when `Jason` library is not available
- Removed hardcoded list of `phx_*` attributes

# 0.1.0
Initial release :)


text:
# Inferential Analysis between Time of Day and Day of the Week on Tip Percentage for Taxi rides in New York City

## Authors
- Alexander Hinton
- Mengzhe Huang
- Yijia Qin

## Summary
The research question for this data analysis project is whether the time of day, and day of the week are associated with tip generosity of riders in New York City taxis. Taxi drivers often have autonomy in there working schedules, and would be interested in which times of the day and week are associated with the highest average tip percentages, and whether these differences are significant.

The original source of our data is [New York Open Data](https://data.cityofnewyork.us/Transportation/2017-Yellow-Taxi-Trip-Data/biws-g3hs), which provides a comprehensive dataset of all taxi rides in New York City. We have used a [sample](https://raw.githubusercontent.com/jamesh4/yellow_tripdata_2017_02/master/taxi_smaller.csv) of 1 million rides from this dataset, from the month of February 2017.

After an [Exploratory Data Analysis](https://github.com/UBC-MDS/DSCI522_GR406/blob/master/src/eda/eda.ipynb) on our dataset, we fit an interactive linear model using the mean tip percentage as our independent variable. Statistically significant associations between time of day and  differences in mean tip percentage were found, while controlling for a handful of potential confounders.

## Report
The final report can be read [here](https://github.com/UBC-MDS/DSCI522_GR406/blob/master/doc/report.md).

## Usage and flowchart
There are three ways to run the analysis on your local machine. The first step is to clone this repository. The first method requires installation of Docker and the rest two methods require all dependencies to be installed before running the analysis.

#### Method 1: Using Docker
Note - the instructions below depends on running this in a unix shell (e.g., terminal or Git Bash), if you are using Windows Command Prompt, replace /$(pwd) with PATH_ON_YOUR_COMPUTER.

1. Install and run [Docker](https://www.docker.com/get-started)
2. Navigate to the root of this repo and type the following commands:
```
docker run --rm -v /$(pwd):/home/DSCI522_GR406 jamesh4/dsci522_gr406 make -C /home/DSCI522_GR406 all
```
3. To undo the analysis, type the following commands:
```
docker run --rm -v /$(pwd):/home/DSCI522_GR406 jamesh4/dsci522_gr406 make -C /home/DSCI522_GR406 clean
```

#### Method 2: Using Make
From the root of this project directory, run the command:

```
make all
```
To remove all the results of the analysis, run the command:

```
make clean
```

#### Method 3: Using the command line
To run each script independently, run the following commands in order from the root directory of the project:

```
# download data from web
python src/load_csv.py https://raw.githubusercontent.com/jamesh4/yellow_tripdata_2017_02/master/taxi_smaller.csv data/taxis.csv

# clean and process the data
Rscript src/data_cleaning.R data/taxis.csv data/taxis_clean.csv

# create EDA visualizations
Rscript src/eda/eda.R data/taxis_clean.csv results/fig/

# statistical modelling
Rscript src/modelling.R data/taxis_clean.csv results/

# generate report
Rscript -e "rmarkdown::render('doc/report.Rmd')"
```

#### Makefile structure:

#### Flowchart:

### Dependencies
- R version 3.6.1 and R packages:
    - MASS		7.3 - 51.4
    - tidyverse	1.3.0
    - broom		0.5.2
    - repr		1.0.2
    - modelr	0.1.5
    - ggplot2	3.2.1
    - gridExtra	2.3
    - ggridges	0.5.1
    - GGally	1.4.0
    - docopt	0.6.1
    - RCurl		1.98 -  1.1
- Python version 3.7.3 packages:
    - docopt     0.6.2
    - pandas     0.24.2
    - validators 0.14.2

#### References
1. New York City Open Data, 2017 Yellow Taxi Trip Data, https://data.cityofnewyork.us/Transportation/2017-Yellow-Taxi-Trip-Data/biws-g3hs

2. Data.World Open Data, Yellow Trip Data February 2017, https://data.world/new-york-city/yellow-tripdata-february-2017


text:
title = "[Award] The Second Prize in National Computer Design Contest Tianjin Division"                                      summary = " The China University Computer Design Contest (hereinafter referred to as the "Contest") is organized by the Ministry of Education’s Higher School Computer Professional Teaching Guidance Committee, the Ministry of Education’s Higher School Software Engineering Teaching Guidance Committee, the Ministry of Education’s Higher School Computer Course Teaching Guidance Committee, and the Ministry of Education The school's liberal arts computer basic teaching guidance subcommittee and China Education Television jointly sponsored. "

date = "2020-07-28T00:00:00+00:00"
tags = ["Award", "Deep Learning", "5G"]
authors = ["zhixianzhang","fanjiawen"]

[header]
image = ""
caption = ""

+++

This project is based on visual AI and 5G edge computing technology, through the functional customization of embedded devices, to realize the UAV intelligent patrol system. Through OpenCV for image processing, Yolo V4 for target detection and TensorFlow for deep learning, and through neural network algorithms, drones can autonomously extract features of motor vehicles and non-motor vehicles that violate traffic laws, and use embedded platforms and 5G The network transmission module empowers the UAV to automatically cruise and transmit to the cloud platform, and visualize the patrol mission through a customized App. It can replace the patrol officers to perform cumbersome patrol tasks that consume less time and effort, especially to solve the problem of indiscreet, large number of non-motor vehicles, and difficulty in checking and correcting the "one helmet and one area". It can effectively and intelligently identify most traffic violations.

repository: TJNU-iOS-Club/BlogSrc-Of-TJNU-iOS-Club

repo_name: TJNU-iOS-Club/BlogSrc-Of-TJNU-iOS-Club


text:
#### Version: 1.5 (built with Ghidra 10.0.2)
- [#9](https://github.com/kotcrab/ghidra-allegrex/issues/9) - Fixed issues with loading binaries with debug symbols

#### Version: 1.4 (built with Ghidra 10.0.2)
- Added `PpssppExportSymFile` script

#### Version: 1.3 (built with Ghidra 10.0.2)
- Updated to Ghidra 10.0.2
- [#2](https://github.com/kotcrab/ghidra-allegrex/issues/2) - Fixed wrong endianness for `long long` return values

#### Version: 1.2 (built with Ghidra 9.2.1)
- Updated to Ghidra 9.2.1

#### Version: 1.1 (built with Ghidra 9.1.2)
- [#6](https://github.com/kotcrab/ghidra-allegrex/issues/6) - Rebasing image after importing can fail
  - Note: This fix will only apply to new projects

#### Version: 1.0 (built with Ghidra 9.1.2)
- [#5](https://github.com/kotcrab/ghidra-allegrex/pull/5) - Added bitrev, mfic, mtic, and wsbw instructions
- [#4](https://github.com/kotcrab/ghidra-allegrex/pull/4) - Added Coprocessor 0 registers and transfers

#### Version: 0.9
- Initial release

repository: John-K/ghidra-allegrex

repo_name: John-K/ghidra-allegrex


text:
# Plug and Play Application Plugins

Plugins are a convinent way to extend the Vue base class with custom mixins, directives and prototype methods.

The plugins are automatically loaded and mounted without having to manually register them, you can disable plugins with a config later explined.

In addition to standard extending there is an optional hook export that allows you to tap into a Vue `vm` instance after it has been created giving you full `$root` access and global event exposure so you can register listeners within your plugin and fire logic inside your plugin as well as fire your own Vue events.

This package also comes with application level life cycle events so that your plugin can perform logic on `app:` based events such as when initalization has compleated or user has authenticated.

Plugins can `emit` their own events and other plugins listen for them.

# Creating a Plugin

// TODO Document

### Plugin Configuration Data

// TODO Document

### Disabling a plugin

// TODO Document

## Plugin Hooks

A plugin hook allows you to hook into the Vue instance, `vm` is a reference to the instance of Vue that triggred it.

You can use this to acces the `$root` data and logic as well as any references and other features available.

For example you can use a hook to establish an event listener from within the plugin and run plugin logic on **Life Cycle Events** from Vue, App Events and Custom Events, See **Hook LifeCycle events** below for a list of supported default events.

```javascript
export const hook = (vm) => {

    vm.$on('app:initialized', () => {

        vm.authCheck();

    });

};
```

The above example triggers the `authCheck` method registered by another plugin.

It is easy to share logic btween plugins, establish events and listners between them as well as the main Vue instance and it's components.

### Hook LifeCycle events

// TODO Document

##### hook:beforeMount

##### hook:mounted

##### hook:beforeUpdate

##### hook:updated

##### app:booted

##### app:initializing

##### app:initialized

##### app:authenticating

##### app:authenticated

repository: vue-pie-laravel/core

repo_name: vue-pie-laravel/core


text:
# gentoo-build

shell scripts that builds systemd based gentoo box for x86_64 platform.

## Usage

### Basic

```
$ cp ./variables{.sample,}.sh
$ vi ./variables.sh
$ ./minify.sh /tmp/gentoo-build.sh
$ scp /tmp/gentoo-build.sh installer:/tmp/gentoo-build.sh
$ ssh installer /tmp/gentoo-build.sh
```

### Packer (virtualbox-iso, amazon-ebs)

```
$ packer build --var 'subnet_id=subnet-XXX' --var 'vpc_id=vpc-XXX' packer/gentoo.json
$ packer build --only=virtualbox-iso --var 'subnet_id=' --var 'vpc_id=' packer/gentoo.json
```

packer build should be run in the repository root directory.

## Built images using packer

You can use these if you can trust me. Note that the images are provided w/o any warranty. And the images can be removed w/o any notices.
If you want persistent copy, build by your own.

### Vagrant (virtualbox, qemu, aws)

https://atlas.hashicorp.com/sorah/boxes/gentoo

Not frequently updated

### AWS EC2 AMI

<!-- s/\v^(.+): (.+)$/- \1: [`\2`](https:\/\/console.aws.amazon.com\/ec2\/home?region=\1#launchAmi=\2)/ -->

gentoo-20170706-595e850a-1ade-86bb-c236-ecf2ea883c22

- ap-northeast-1: [`ami-59d1ce3e`](https://console.aws.amazon.com/ec2/home?region=ap-northeast-1#launchAmi=ami-59d1ce3e)
- ap-south-1: [`ami-433c452c`](https://console.aws.amazon.com/ec2/home?region=ap-south-1#launchAmi=ami-433c452c)
- ap-southeast-1: [`ami-225fd541`](https://console.aws.amazon.com/ec2/home?region=ap-southeast-1#launchAmi=ami-225fd541)
- ca-central-1: [`ami-9b7cc3ff`](https://console.aws.amazon.com/ec2/home?region=ca-central-1#launchAmi=ami-9b7cc3ff)
- eu-central-1: [`ami-0442e26b`](https://console.aws.amazon.com/ec2/home?region=eu-central-1#launchAmi=ami-0442e26b)
- eu-west-2: [`ami-16c8de72`](https://console.aws.amazon.com/ec2/home?region=eu-west-2#launchAmi=ami-16c8de72)
- sa-east-1: [`ami-e5671289`](https://console.aws.amazon.com/ec2/home?region=sa-east-1#launchAmi=ami-e5671289)
- us-east-1: [`ami-0d64601b`](https://console.aws.amazon.com/ec2/home?region=us-east-1#launchAmi=ami-0d64601b)
- us-east-2: [`ami-ceedccab`](https://console.aws.amazon.com/ec2/home?region=us-east-2#launchAmi=ami-ceedccab)
- us-west-1: [`ami-a3f8d7c3`](https://console.aws.amazon.com/ec2/home?region=us-west-1#launchAmi=ami-a3f8d7c3)
- us-west-2: [`ami-77c6d50e`](https://console.aws.amazon.com/ec2/home?region=us-west-2#launchAmi=ami-77c6d50e)

## Note

### Packer virtualbox support

- default user name is `vagrant`, and its password is `vagrant`
- NOPASSWD sudo access enabled for `wheel` group, which vagrant user belongs to.

### Packer EC2 support

- cloud-init has enabled
- default user name is `gentoo`
  - NOPASSWD sudo access enabled for the user
  - default user creation is done via cloud-init.
- IPv6 is not supported out-of-the-box
  - As of Jan 31st, AWS' DHCPv6 server implementation doesn't respond to packets sent from systemd-networkd :/

repository: OndrejHome/gentoo-build

gha_language: Shell

repo_name: OndrejHome/gentoo-build


text:
# React SVG Pan Zoom - Migrate from V2 to V3

## Some props are now required.

React SVG Pan Zoom contains two different viewer: `ReactSVGPanZoom` and `UncontrolledReactSVGPanZoom`.

*ReactSVGPanZoom* is the preferred way to use this component. It works as a stateless component and, unlike the previous version, the following props are now required.

- `tool` - The tool actually used.
- `onChangeTool(tool)` - An handler called when there's a tool change request.
- `value` - The actual camera view on the image (observer point of view).
- `onChangeValue(value)` - An handler called when the value is changed (may happens for different reasons).

You can thing to it as a React form input field.
```javascript
class MyViewer extends React.Component {
  state = {
    value:  {},
    tool: TOOL_NONE,
  }

  render() {
    return (
      <ReactSVGPanZoom
        width={200} height={400}
        tool={this.state.tool}
        onChangeTool={tool => this.setState({tool})}
        value={value}
        onChangeValue={value => this.setState({value})}
      >....</ReactSVGPanZoom>
    )
  }
}
```
If you don't need to handle tool and value in your code, just use the `UncontrolledReactSVGPanZoom` component that does this work for you.

To use it just replace:

```javascript
import {ReactSVGPanZoom} from 'react-svg-pan-zoom';
```
with
```javascript
import {UncontrolledReactSVGPanZoom} from 'react-svg-pan-zoom';
class MyViewer extends React.Component {
  render() {
    return (
      <UncontrolledReactSVGPanZoom
        width={200} height={400}
      >....</ReactSVGPanZoom>
    )
  }
}
```

## Toolbar and miniature props are now moved into two dedicated objects

Replace

```javascript
<ReactSVGPanZoom
    miniaturePosition="left"
    miniatureBackground="#fff"
    miniatureWidth={100}
    miniatureHeight={80}
    toolbarPosition="right"
/>
```

with
```javascript
const minitiatureProps = {
  miniaturePosition: "left",
  miniatureBackground: "#fff",
  miniatureWidth: 100,
  miniatureHeight: 80
}

const toolbarProps = {
  toolbarPosition: "right"
}

<ReactSVGPanZoom
    toolbarProps={toolbarProps}
    miniatureProps={miniatureProps}
/>
```

repository: hardik-satasiya/react-svg-pan-zoom

repo_name: hardik-satasiya/react-svg-pan-zoom


text:
# Weather App - Android Technical Task #

### [👉 Video Demo for this task on youtube 👈](https://youtu.be/S6ppgoK1-rM)

### Weather application
- [x] Created android screen that has search bar on top.
- [x] Detected current location of the customer.
- [x] Using https://openweathermap.org/api. Current weather data web service to provide all the necessary data.
- [x] All permissions is properly handled .
- [x] There are no restrictions on use of external libraries.

### Project Dependency Graph ###
- App module
  depend on core + feature search current weather + library location tracker : contains app start point it may be a splash screen.
- Core module
  depend on nothing  : contains all sharable data among different modules.
- Feature Search current weather Module
  depend on core + library location tracker : contain search weather feature related ui and other staffs.
- Library location tracker
  depend on core : contain code of getting current user location.

### Use domain specific langauge ###
- Make gradle scripts easy
- Support Kotlin for better dependencies management by Using Domain-Specific Languages.
- Support autocomplete

### Modular architecture ###
- Speeds up builds
- Enable on demand delivery
- Simplify development
- Reuse modules across apps
- Experiment with new technologies
- Scale development teams
- Enables refactoring
- Simplifies test automation

### MVVM Inside each module
- each developer inside android team has a free to select suitable architecture for his module.

### Dependency injection with Hilt ###
- Hilt is a dependency injection library for Android that reduces the boilerplate of doing manual dependency injection in our project.

### Enable AppCenter Pipelines ###
- Support CI so i can check different stages like build and run unit test
  before merge any branch to master branch.

### Detekt ###
- to make code style analysis and be sure follow best practice for writing kotlin code.

### Firebase crashlytics ###
- to rack bugs even though app moved to production

### To avoid 64k functions problem and get smaller apk ###
- Enables code shrinking, obfuscation, and optimization for only
- Enables resource shrinking, which is performed by the

### Data binding
- The Data Binding Library automatically generates the classes required to bind the views in the layout with your data objects.

### leakCanary
- to detect memory leak through debugging process that will improve app performance as well.

### Truth For unit test its recommended from google
- write unit test for [Search Validator Class](https://github.com/MostafaAnter/Weather_application/blob/master/feature_search_current_weather/src/test/java/app/anter/feature_search_current_weather/ui/usecase/SearchValidatorTest.kt)

### Reactive programming (Coroutines)
Coroutines is Google recommended solution for asynchronous programming on Android. Noteworthy features include the following:

- Lightweight: You can run many coroutines on a single thread due to support for suspension, which doesn't block the thread where the coroutine is running. Suspending saves memory over blocking while supporting many concurrent operations.
- Fewer memory leaks: Use structured concurrency to run operations within a scope.
- Built-in cancellation support: Cancellation is propagated automatically through the running coroutine hierarchy.
- Jetpack integration: Many Jetpack libraries include extensions that provide full coroutines support. Some libraries also provide their own coroutine scope that you can use for structured concurrency.

### PermissionsDispatcher ###
PermissionsDispatcher provides a simple annotation-based API to handle runtime permissions.
- Fully Kotlin/Java support
- Special permissions support
- 100% reflection-free

### License
    Copyright [2021] [Mostafa Anter]

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

    http://www.apache.org/licenses/LICENSE-2.0
    Unless required by applicable law or agreed to in writing,
    software distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and limitations under the License.


text:
Scripting and Automation
========================

Q1) Bash-Fu, Python Prowess, Perl Perfection, Ruby Revelation...
----------------------------------------------------------------
Drop a script in this directory which does something amazing.

Q2) Explain
-----------
What are the interesting parts of your script? What do they do?

Q3) Automated Provisioning
--------------------------
Puppet, Chef, Salt, Fabric, vCenter. What are they? Tell me why I should care
about them. Describe your experiences with some or all of them.

repository: ETCM/basic-sysadmin-test

repo_name: ETCM/basic-sysadmin-test


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

# Uptime Checker

A php library to monitor website uptime

## Table of contents

- [Table of contents](#table-of-contents)
- [Installation](#installation)
- [Usage](#usage)
  - [Instantiation](#instantiation)
  - [Perform an uptime check](#perform-an-uptime-check)
  - [The result array](#the-result-array)
- [Testing](#testing)
- [License](#license)

## Installation

Install via [composer](https://getcomposer.org/doc/00-intro.md)
```sh
composer require hedii/uptime-checker
```

## Usage

### Instantiation

Create a uptime checker instance:

```php
<?php

// require composer autoloader
require '/path/to/vendor/autoload.php';

// instantiate
$checker = new Hedii\UptimeChecker\UptimeChecker();
```

Alternatively, you can pass a GuzzleHttp\Client instance as a parameter if you want to set your own http client options ([see Guzzle documentation](http://docs.guzzlephp.org/en/latest/request-options.html)):

```php
// instantiate with the http client as a parameter
$checker = new Hedii\UptimeChecker\UptimeChecker(new Client([
    'delay' => 1000,
    'allow_redirects' => false
]));
```

### Perform an uptime check

Call the `check($url)` method with an url as a parameter to perform the uptime check.

```php
$checker = new Hedii\UptimeChecker\UptimeChecker());
$result = $checker->check('http://example.com);
```

The result of this method is an array with with the check report information. The value of `success` indicates if the website is up or down:

```
array(5) {
    'uri' => "http://example.com"
    'success' => true
    'status' => 200
    'message' => "OK"
    'transfer_time' => 0.765217
}
```

### The result array

| Field           | Type    | Description                                           |
| --------------- | ------- | ----------------------------------------------------- |
| `uri`           | string  | The url to test                                       |
| `success`       | boolean | Whether the uptime test is successful or not          |
| `status`        | integer | The http response status code                         |
| `message`       | string  | The http response message or the client error message |
| `transfer_time` | float   | The transfer time in seconds                          |

## Testing

```
composer test
```

## License

hedii/uptime-checker is released under the MIT Licence. See the bundled [LICENSE](https://github.com/hedii/uptime-checker/blob/master/LICENSE.md) file for details.

repository: Burchikpol/PixelParser

gha_language: Vue

repo_name: Burchikpol/PixelParser


text:
NoBurglar
=========

NoBurglar is a simple, automated way to turn on lights and TV late in the evenings when you're not in town; so that burglars walking/driving by casually will not suspect that your house is empty.

Hardware Setup
---------------

- [Weaved SmartPlug](https://developer.weaved.com/portal/members/plug_alpha_landing.php) (along with IR Blaster)
- A regular floor lamp
- Your living room TV
- A computer to run the NoBurglar code on (I'm using a [Raspberry Pi](https://www.raspberrypi.org))

Connect the floor lamp to the SmartPlug. Verify that it turns on/off using the button on top of the Plug. Position the IR blaster such that it is directly facing the TV.

Software Setup
--------------

### SmartPlug Setup

- Set up the Plug using [these](https://developer.weaved.com/portal/members/plug_instructions.php) instructions and make sure SSH access is enabled
- Set up public-key authentication for SSH ([instructions](http://wiki.openwrt.org/doc/howto/dropbear.public-key.auth)) so that the computer running NoBurglar can connect to the `root` account on the Plug without a password
- Make sure the IR blaster is set up and identify the POWER ON and POWER OFF IR codes for your TV ([instructions](http://forum.weaved.com/t/using-the-ir-blaster-on-the-weaved-smart-plug/)); note - it's preferable to use the separate on and off codes but if your TV only has a single POWER code, use that for both

### NoBurglar Setup

Settings are defined at the top of [noburglar.py](noburglar.py) in between `BEGIN Configuration` and `END Configuration`. Parameters to be set are the IP address for the Plug, daily start and end times, IR codes, TV on duration (in the interest of saving power, we may not want the TV to be on during the entire time window when the light is on).

Using NoBurglar
---------------

### Running NoBurglar

Once the setup is done, simply -

    $ python noburglar.py

### Enable/Disable NoBurglar

If you're running NoBurglar as part of system-wide init scripts, this is handy way to enable/disable the functionality without having to kill/restart the whole thing. Put `1` or `0` in the [enabled](enabled) file. It is enabled by default. To disable -

    $ echo 0 > enabled

To enable it again -

    $ echo 1 > enabled

License
-------
[FreeBSD](LICENSE)


text:
Contributing
============

All projects under the Pylons Projects, including this one, follow the
guidelines established at [How to
Contribute](https://pylonsproject.org/community-how-to-contribute.html) and
[Coding Style and
Standards](https://pylonsproject.org/community-coding-style-standards.html).

You can contribute to this project in several ways.

* [File an Issue on GitHub](https://github.com/Pylons/peppercorn/issues)
* Fork this project and create a branch with your suggested change. When ready,
  submit a pull request for consideration. [GitHub
  Flow](https://guides.github.com/introduction/flow/index.html) describes the
  workflow process and why it's a good practice. When submitting a pull
  request, sign
  [CONTRIBUTORS.txt](https://github.com/Pylons/peppercorn/blob/master/CONTRIBUTORS.txt)
  if you have not yet done so.
* Join the IRC channel #pyramid on irc.freenode.net.

Git Branches
------------
Git branches and their purpose and status at the time of this writing are
listed below.

* [master](https://github.com/Pylons/peppercorn/) - The branch on which further
  development takes place. The default branch on GitHub.

repository: maxim-s-barabash/peppercorn

repo_name: maxim-s-barabash/peppercorn


text:
#### `Kanza_cli` is a simple command line tool to generate folder and file structure for your Flutter apps.

#### To use it, you should do the followings:

##### 1. Firstly, you should activate dart cli to run it globally:

    dart pub global activate kanza_cli

 After successful activation, you can use it.

##### 2. Ensure that, you are in the your Flutter project directory, because it will generate folders and files in the `lib` folder. Then write a simple command yo generate:

    kanza_cli create

And it will generate the following structure:

![structure](https://github.com/thisisyusub/kanza-cli/blob/master/screenshoots/structure.png)

repository: NijatTagizada/kanza-cli

repo_name: NijatTagizada/kanza-cli


text:
---
layout: page
title: Contact
permalink: /contact/
feature-img: "img/color.png"
---

Questions? Feedback? I'd love to hear from you!

<form action="https://getsimpleform.com/messages?form_api_token=b85d02c228e45d9fdb0cb84c7914a227" method="post">
  <!-- the redirect_to is optional, the form will redirect to the referrer on submission -->
  <input type='hidden' name='redirect_to' value='http://rachelcolby11.github.io/thank-you/' />
  <input type='text' name='name' placeholder='Your Full Name' />
  <input type='email' name='email' placeholder='Your E-mail Address' />
  <textarea name='message' placeholder='Write your message ...'></textarea>
  <input type='submit' value='Send Message' />
</form>


text:
---
---

[//]: # (

 )

## Making Screen Captures

Screen captures are very useful tools for sharing what you are seeing on the computer. Use them to:

* Help make instructions easier to follow.
* To help demonstrate a bug or to capture a long or complex error message.
* To submit evidence of your work.

## The **Snipping Tool** (Windows)

[How to Take Screenshots Using Snipping Tool in Windows 10](https://www.techbout.com/screenshots-using-snipping-tool-in-windows-10-30452/)


text:
# Input #

The Input is part of the *chayns-components* package. It can be installed via npm:

    npm install -S chayns-components@latest

## Usage ##

The input has to be imported:

```jsx harmony
import { Input } from 'chayns-components';
```

You can use the Input like in the [example](https://github.com/TobitSoftware/chayns-components/blob/master/examples/react-chayns-input/Example.jsx).

## Props ##

The following properties can be set on the Input-Component

| Property     | Description                                                                       | Type           | Default Value |
|--------------|-----------------------------------------------------------------------------------|----------------|---------------|
| type         | The type that should be set on the input (e.g. text, password, number)            | string         | "text"        |
| style        | Additional styles that should be set to the input                                 | object         |               |
| className    | Additional CSS-Classes that should be set to the input                            | string         |               |
| placeholder  | Animated placeholder that will be shown inside the input                          | string         |               |
| defaultValue | the value does not update if this prop updates                                    | string/number  |               |
| value        | the value updates if this prop updates                                            | string/number  |               |
| onChange     | returns the value as an result of the onInput-event (if a RegExp is given a second value is returned indicating if the input is valid or not) | function  |  |
| onEnter      | returns the value if user clicks enter | function  |  |
| onKeyUp      | returns the onKeyUp event | function  |  |
| onBlur       | returns the value if the input lost its focus (if a RegExp is given but it does not match the input the return value is null) | function  |  |
| regExp       | The input will check if the entered text is valid (see Regular Expressions)       | string, RegExp |               |
| inputRef     | Exposes the input DOM Ref to the parent component                                 | func           |               |
| invalid      | Marks the input as invalid                                                        | bool           | false         |
| icon         | Icon shown on the right side (only dynamic input)                                 | string/object  |               |
| onIconClick  | Icon onClick Event (only dynamic input)                                           | func           | clear value   |
| dynamic      | Use dynamic input                                                                 | bool           | false         |
| customProps  | CustomProps for the html input element                                            | object         |               |
| stopPropagation | Stops the click propagation to parent elements                                 | bool           | false         |
| required     | Input is invalid if there is no value                                             | bool           | false         |
| disabled     | Disables the input                                                                | bool           | false         |

Note: The functions onEnter, onChange and onBlur return three values: the input value, if the input is valid and the event.

repository: MariusGertdenken/chayns-components

repo_name: MariusGertdenken/chayns-components


text:
# ScanNet Benchmark Scripts

We provide scripts for evaluation of the tasks in the [ScanNet benchmark](http://kaldir.vc.in.tum.de/scannet_benchmark), as well as some helper scripts which prepare and visualize data.

These scripts have been developed and tested with Python 2.7.

## Evaluation Scripts
The evaluation for both 2D and 3D semantic label and instance segmentation tasks are adapted from the [CityScapes evaluation](https://github.com/mcordts/cityscapesScripts), and provided in [2d_evaluation](2d_evaluation) and [3d_evaluation](3d_evaluation), respectively. The evaluation for the scene type classification task is provided in [scene_type_evaluation](scene_type_evaluation).

Note that visualization and data preparation scripts for semantic instance and label prediction depend on the ScanNet label mapping file `scannetv2-labels.combined.tsv` to convert labels into the NYUv2 40-label set, which we use for evaluation.

Please see the [benchmark evaluation documentation](http://kaldir.vc.in.tum.de/scannet_benchmark/documentation) for more information about evaluation data formats and label sets.

## Helper Scripts
* 2D:
  * [2d_helpers](2d_helpers) contains helper scripts for converting ScanNet label images (`*_2d-label.zip`, `*_2d-label-filt.zip`) to the NYUv2 40-label set as 8-bit `png`s, as well as converting ScanNet instance images (`*_2d-instance.zip`, `*_2d-instance-filt.zip`) to 16-bit `png`s containing `[NYUv2 40-label]*1000+instance_id`. An already pre-processed subset of approximately 25,000 frames is available to download with the ScanNet download.
  * `util.visualize_label_image` and `util.visualize_instace_image` can be used to visualize these processed label and instance images (assumes NYUv2 40 labels).

* 3D:
  * [3d_helpers](3d_helpers) contains helper scripts for exporting a train scan into the 3D evaluation format for semantic instance and label segmentation.
  * `3d_helpers/visualize_labels_on_mesh` can be used to visualize semantic labels on a mesh (assumes NYUv2 40 labels).

* Scene Types:
  * `scene_type_helpers/get_scene_type_for_scan` can be used to get the scene type id from the info `<scanId>.txt` file for a scan in the ScanNet release.

repository: ScanNet/ScanNet

gha_language: C

gha_license_id: NOASSERTION

repo_name: ScanNet/ScanNet


text:
# Augmented-debug README

This sample extension shows how a [`vscode.DebugAdapterTracker`](https://github.com/microsoft/vscode/blob/b6ae21e6e2e7255978993df45c1317a869170d21/src/vs/vscode.d.ts#L9649-L9688) can be used to augment a debug session with additional information.

The following screencast shows a new scope "GPU" in the VARIABLES view that is fed by the extension.
The underlying C++ debugger is unmodified and completely unaware of this.

![Additional GPU section in VARIABLES view](images/gpu.gif)

The complete source is [here](https://github.com/weinand/augmented-debug/blob/master/src/extension.ts).

# Run the Sample

- run `git clone https://github.com/weinand/augmented-debug.git`
- run `cd augmented-debug`
- run `npm install`
- run `code .`
- install the C++ extension
- F5 -> new window opens
- in new window press F5 -> debugger breaks on line 4 and VARIABLES view shows a "GPU" scope
- expand GPU scope -> 3 registers are shown
- continue stepping -> registers under GPU update their values

## Please Note:

The `vscode.DebugAdapterTracker` API was designed to **tap** the communication between VS Code and debug adapters. It was not designed to **modify** messages in transit. So this example actually shows a use case that is not officially supported.

However, we are currently working on another (similar) API that supports intercepting and modifying DAP messages. And as long as this API is not a part of the official VS Code extension API (i.e. `vscode.d.ts`), we will continue to support the "unofficial" use case.

### 1.0.0

Initial release.

repository: weinand/augmented-debug

gha_language: TypeScript

repo_name: weinand/augmented-debug


text:
# terraform-aws-eks
## Summary
This module implementes an EKS cluster and associated worker groups. It utilised the new mixed instance type autoscaling groups allowing you to switch between spot and on demand as required.

To improve the security of your clusters this module defaults to expecting KIAM to be deployed to manage IAM Role credentials for Pods. If you are deploying a demo cluster where security is not as important you can disable this with the `enable_kiam=false`. Then the the IAM Permissions managed by this module will be assigned directly to the worker nodes.

## Inputs
| Name | Description | Type | Default | Required |
|------|-------------|:----:|:-----:|:-----:|
| autotag\_subnets | Automatically add Kubernetes tags to subnets. Requires aws-cli to be available. | string | `"false"` | no |
| autotag\_profile | Defines an optional AWS profile to use with aws-cli when auto-tagging subnets | string | `"false"` | no |
| cluster\_access\_additional\_sg | Security groups allowed access to the API server | list | `[]` | no |
| cluster\_access\_additional\_ip | CIDRs allowed access to the API server | list | `[]` | no |
| cluster\_endpoint\_private\_access | Enable Amazon EKS private API server endpoint. | string | `"false"` | no |
| cluster\_endpoint\_public\_access | Enable Amazon EKS public API server endpoint. | string | `"true"` | no |
| cluster\_name | Name of the EKS Cluster | string | n/a | yes |
| cluster\_version | EKS Cluster Version | string | n/a | yes |
| enable\_alb\_ingress | Enable required components for ALB Ingress | string | `"true"` | no |
| enable\_cert\_manager | Enable required components for Cert-Manager | string | `"true"` | no |
| enable\_container\_insights | Enable required components for Cloudwatch Container Insights | string | `"true"` | no |
| enable\_cluster\_autoscaler | Enable required components for Cluster Autoscaler | string | `"true"` | no |
| enabled\_cluster\_log\_types | A list of the desired control plane logging to enable | list | `["api", "audit", "authenticator", "controllerManager", "scheduler"] ` | no |
| enable\_ecr | Enable required components for Amazon ECR Read Only | string | `"true"` | no |
| enable\_external\_dns | Enable required components for External-DNS | string | `"true"` | no |
| enable\_kiam | Create IAM roles to be used by KIAM. Enabling this requires KIAM to be active and deployed to your cluster for IAM roles to work. | string | `"true"` | no |
| enable\_ssm | Enable required components for SSM | string | `"true"` | no |
| enable\_velero | Enable required components for Velero | string | `"true"` | no |
| private\_subnets | Private tier subnet list | list | n/a | yes |
| public\_subnets | Public tier subnet list | list | n/a | yes |
| vpc\_id | VPC ID for EKS Cluster | string | n/a | yes |
| worker\_group\_count | Count of worker groups. Set to 0 to disable worker creation | string | `"1"` | no |
| workers | List of worker groups | list | n/a | yes |

## Worker Group Options
It is possible to customise individual parameters on the the workers list.

| Name | Description | Type | Default | Required |
|------|-------------|------|---------|----------|
| additional\_userdata | Userdata to append to the standard userdata | string | `""` | no |
| ami\_id | AMI ID | string | Most Recent EKS Optimized AMI | no |
| autoscaling\_enabled | Allows cluster-autoscaler to manage this ASG | string | `"true"` | no |
| desired\_capacity | ASG desired capacity. Ignored after creation | string | `"1"` | no |
| detailed\_monitoring | Enable EC2 detailed monitoring | string | `"false"` | no |
| enabled\_metrics | A list of ASG metrics to enable | list(string) | `null` | no |
| iam\_role\_name | Override the role that this module generates | string | `""` | no |
| instance\_types | Instance types used in the ASG | list(string) | `["m5.large", "m4.large"]` | no |
| kubelet\_extra\_args | Additional arguments to pass to the kubelet | string| `""` | no |
| max\_size | ASG maximum size | string | `"10"` | no |
| min\_size | ASG minimum size | string | `"1"` | no |
| on\_demand\_allocation\_strategy | Strategy to use when launching on-demand instances | string | `"prioritized"` | no |
| on\_demand\_base\_capacity | Absolute minimum amount of desired capacity that must be fulfilled by on-demand instances | string | `"0"` | no |
| on\_demand\_percentage\_above\_base_capacity | Percentage split between on-demand and spot instances above the base on-demand capacity | string | `"0"` | no |
| pre\_userdata | Userdata to prepend to the standard userdata | string | `""` | no |
| root\_volume\_size | Root EBS volume size | string | `"100"` | no |
| spot\_allocation\_strategy | How to allocate capacity across the Spot pools | string | `"lowest-price"` | no |
| spot\_instance\_pools | Number of Spot pools per availability zone to allocate capacity | string | `"10"` | no |
| spot\_max\_price | Maximum price youre willing to pay for spot instances. Defaults to the on demand price if blank | string | `""` | no |
| suspended\_processes | A list of processes to suspend for the worker group | list(string) | `null` | no |
| vpc\_subnets | A list of subnets for the ASG to place instances in | list(string) | `var.private_subnets` | no

## Outputs
| Name | Description |
|------|-------------|
| cluster\_certificate\_authority | Cluster Certificate Authority Certificate |
| cluster\_endpoint | Cluster Kubernetes API endpoint |


text:
## Parley Best Practice: Check if a bunch of statements are all true?
[link](http://parley.rubyrogues.com/t/best-practice-check-if-a-bunch-of-statements-are-all-true/2842)

> I tend to extract each condition to a better-named method:

    def send_reminder?
      incomplete? && first_reminder_due? && ...
    end

    private

    def incomplete?
      !completed?
    end

    def first_reminder_due?
      reminder_at <= Time.current
    end

> I agree with `@brandonhilkert` on turning this into a Composed Method of self-describing predicates.

> You might want to extract the whole method to its own object (`Replace Method with Method Object`).

    def send_reminder?
      return false if completed?
      return false if reminder_at > Time.current
      return false if last_reminded_at && last_reminded_at > 23.hours.ago
      return false if reminder_at.hour > Time.current.hour
      return false if reminder_at.min > Time.current.min

      true
    end

## Boolean Externalities
[link](http://devblog.avdi.org/2014/09/17/boolean-externalities/)

    class Episode
      def available_to_user?(user)
        free? || user.current_subscriber?
      end

      def current_subscriber?
        fully_authenticated? && subscription.open
      end

      def fully_authenticated?
        authenticated_accounts? && verified_email?
      end
    end

The problem is that I still had to methodically evaluate each predicate in turn to see which ones were returning unexpected values. *That's eight different methods.*

I can annotate...

    def available_to_user?(user)
      result = (free = free?) || (current_subscriber = user.current_subscriber?)
      puts "episode.free? == #{free}"
      puts "user.current_subscriber? == #{current_subscriber}"
      result
    end

This is good code by most conventional measures. Every method is short and meaningfully named. A current subscriber is someone that is authenticated and has an open subscription.

*The fundamental issue is that while this code makes it very easy to ask “is a user allowed to view this episode?”, when the answer comes back “no”, there is no way to ask “well, why not?”.*

OO's information hiding: "I'll answer your question, but you don't need to know how I arrived at the answer." But we actually do want the information. I do want to tell users why something isn't working as expected.

Boolean externality: In theory, all the important information has been rolled up into one convenient boolean value. In reality, vital knowledge has been lost along the way.

#### Comments

With a Result or Either type, you can communicate more information about why something happened. In Ruby, this would mean returning a tuple of `(true/false, String)` instead of just a bool.

repository: daryllxd/lifelong-learning

gha_language: Elixir

gha_license_id: Unlicense

repo_name: daryllxd/lifelong-learning


text:
## Parameters

`context`
Must be a valid OpenCL context.

`num_devices`
The number of devices listed in `device_list`.

`device_list`
A pointer to a list of devices that are in `context`. `device_list` must
be a non-NULL value. The built-in kernels are loaded for devices
specified in this list.

The devices associated with the program object will be the list of
devices specified by `device_list`. The list of devices specified by
`device_list` must be devices associated with `context`.

`kernel_names`
A semi-colon separated list of built-in kernel names.

## Errors

Returns a valid non-zero program object and `errcode_ret` is set to
`CL_SUCCESS` if the program object is created successfully. Otherwise,
it returns a NULL value with one of the following error values returned
in `errcode_ret`:

-   `CL_INVALID_CONTEXT` if `context` is not a valid context.

-   `CL_INVALID_VALUE` if `device_list` is NULL or `num_devices` is
    zero;

-   `CL_INVALID_VALUE` if `kernel_names` is NULL or `kernel_names`
    contains a kernel name that is not supported by any of the devices
    in `device_list`.

-   `CL_INVALID_DEVICE` if devices listed in `device_list` are not in
    the list of devices associated with `context`.

-   `CL_OUT_OF_RESOURCES` if there is a failure to allocate resources
    required by the OpenCL implementation on the device.

-   `CL_OUT_OF_HOST_MEMORY` if there is a failure to allocate resources
    required by the OpenCL implementation on the host.

## Also see

[`clCreateProgramWithSource`](clCreateProgramWithSource.html),
[`clCreateProgramWithBinary`](clCreateProgramWithBinary.html),
[`clReleaseProgram`](clReleaseProgram.html),
[`clRetainProgram`](clRetainProgram.html), [Cardinality
Diagram](classDiagram.html)

## Specification

[OpenCL 2.1 API Specification, page
198](https://www.khronos.org/registry/cl/specs/opencl-2.1.pdf#page=198)

## Copyright

[Copyright © 2007-2017 The Khronos Group Inc.](copyright.html)

repository: Galarius/vscode-opencl

repo_name: Galarius/vscode-opencl


text:
# VideoCompressor

## Requirements
ExoNode should be working at localhost

## How to Use?
run CompressDemoParallel [fps]

run CompressDemoUsingSwave [fps]

default fps = 25

## How does it works?
CompressDemoParallel:

1 - uses HumbleVideo to decode all frames of the input file and FFMPEG to decode the audio from the file

2 - sends all pairs of consecutive frames to exocute (frame 1,frame 2),(frame 2,frame 3), ..., (frame n-1, frame n)

3 - uses exocute to analyse the differences of each pair of frames, and then decide if the pair has a keyframe on frame2

4 - using JCodec, encodes all frames back together with the information if every frame should be a keyFrame or not, FFMPEG encodes the audio

5 - results in a compressed video file

CompressDemoUsingSwave:

  all the same tasks are done using swave transformations.

Check VideoCompression.png, compress.grp for a better understanding

Check VideoCompressionParallel.png(available soon) and compressParallel for a better understanding

### Swave conversion examples
In the swaveToExocuteDemo folder we have several examples
of using the toolkit conversions from Swave to ExoGraph.

This examples show that the ExoGraph resulted from the conversions produce
the same result has the original Swave running locally.

repository: exocute/demos

repo_name: exocute/demos


text:
galileo-gpio
============

galileo-gpio is a simple node.js based library to help access the GPIO of the Intel Galileo (Yocto Linux). It's modelled loosely around the built-in ``fs`` module and based on pi-gpio.

```javascript
var gpio = require("galileo-gpio");

gpio.open(27, "output", function(err) {		// Open pin 27 for output
	gpio.write(27, 1, function() {			// Set pin 27 high (1)
		gpio.close(27);						// Close pin 27
	});
});
```
## Under Development

This project is under development right now and isn't working yet. Soon it's finished I will update this README.

## Installation

If you haven't already, get node and npm on the Intel Galileo. The simplest way is:

	sudo apt-get install nodejs npm

The Intel Galileo's GPIO pins require you to be root to access them. That's totally unsafe for several reasons.

Do ``cd`` to your project directory and use npm to install galileo-gpio in your project.

	npm install galileo-gpio

That's it!

## Usage

### .open(pinNumber, [direction = "output"], [callback])

Aliased to ``.export``

Makes ``pinNumber`` available for use.

* ``pinNumber``: The pin number to make available. Remember, ``pinNumber`` is the physical pin number on the Intel Galileo.
* ``direction``: (Optional) Direction can either be ``input`` or ``output``, depending on what you want to do with the pin. You could alternatively use ``in`` or ``out``. Default: ``output``.
* ``callback``: (Optional) Will be called when the pin is available for use. May receive an error as the first argument if something went wrong.

### .close(pinNumber, [callback])

Aliased to ``.unexport``

Closes ``pinNumber``.

* ``pinNumber``: The pin number to close. Again, ``pinNumber`` is the physical pin number on the Intel Galileo.
* ``callback``: (Optional) Will be called when the pin is closed. Again, may receive an error as the first argument.

### .setDirection(pinNumber, direction, [callback])

Changes the direction from ``input`` to ``output`` or vice-versa.

* ``pinNumber``: As usual.
* ``direction``: Either ``input`` or ``in`` or ``output`` or ``out``.
* ``callback``: Will be called when direction change is complete. May receive an error as usual.

### .getDirection(pinNumber, [callback])

Gets the direction of the pin. Acts like a getter for the method above.

* ``pinNumber``: As usual
* ``callback``: Will be called when the direction is received. The first argument could be an error. The second argument will either be ``in`` or ``out``.

### .read(pinNumber, [callback])

Reads the current value of the pin. Most useful if the pin is in the ``input`` direction.

* ``pinNumber``: As usual.
* ``callback``: Will receive a possible error object as the first argument, and the value of the pin as the second argument. The value will be either ``0`` or ``1`` (numeric).

Example:
```javascript
gpio.read(27, function(err, value) {
	if(err) throw err;
	console.log(value);	// The current state of the pin
});
```

### .write(pinNumber, value, [callback])

Writes ``value`` to ``pinNumber``. Will obviously fail if the pin is not in the ``output`` direction.

* ``pinNumber``: As usual.
* ``value``: Should be either a numeric ``0`` or ``1``. Any value that isn't ``0`` or ``1`` will be coerced to be boolean, and then converted to 0 (false) or 1 (true). Just stick to sending a numeric 0 or 1, will you? ;)
* ``callback``: Will be called when the value is set. Again, might receive an error.

## Misc

* To run tests: ``npm install && npm test`` where you've got the checkout.
* This module was created, ``git push``'ed and ``npm publish``'ed all from the Raspberry Pi! The Pi rocks!

## License

(The MIT License)

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

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

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

repository: luigif/galileo-gpio

repo_name: luigif/galileo-gpio


text:
When powered this machine launches *any* ammo item on it's input(s) in a straight line
over it's outputs.

Due to being a fixed machine the bolts/arrows/darts/etc will always travel in a
relatively straight line, you will need to use several launchers to cover a wide path.

Keeping this fed is a real challenge! I suggest you do not start it until the last
moment. Clever engineers can figure out ways to automate recovery of spent bolts and
reloading (minecarts and conveyor belts anyone?).

Input items MUST be on an input tile (a special one tile workshop), projectiles are fired
towards an output tile (which is also required). If multiple output tiles are provided
one is chosen at random each time.

Connecting machines must be built AFTER any mechanical workshop!

gha_language: Lua


text:
# Testing your YOLOv4 model with OpenCV
- `AnnotationGenerator.py`: create annotation file automatically using a pre-trained model (This is useful when you want to train new data and you're too lazy to generate annotation file manually 😴).
```bash
python AnnotationGenerator.py -d <path-to-dataset-folder> -c <path-to-cfg-file> -w <path-to-weights-model> -lb <path-to-label-file>
```
- `FormatConverter.py`: function to convert coordinate's format in YOLOv4 and OpenCV.
- `SplitVideoIntoFrame.py`: split video into frame
```bash
python SplitVideoIntoFrame.py -v <path-to-video> -d <path-to-saved-directory> -e <image-extension> -fps <frames-per-second>
```
- `VehicleDetection.py`: mail file for processing detection.
- `test-obj-detection.py`: test your object detection.