text:
# Movies

This is a fully educational Android application based on free course materials at Udacity platform. The aim is to provide users with various movie charts fetched from themoviedb.org API.

## Dependencies

- Picasso `com.squareup.picasso:picasso:2.5.2`

For development, the newest Android SDK was used. Nowdays, the application is not mantained up to date with the latest Android platform changes.

## Motivation

The ultimate goal was to create my very first Android application including activities, fragments, services, adapters, SQLite database, content provider and master-detail view. See Udacity's [instructions page](https://docs.google.com/document/d/1ZlN1fUsCSKuInLECcJkslIqvpKlP7jWL2TP9m6UiA6I/pub?embedded=true#h.y4qfj5ptq2cv).

## UX

Users basically can:

- Browse movies in grid sorted by actual preference
- View each movie in detail, involving corresponding video trailer links and user reviews
- Save movie to favorites to keep it for later
- Change general settings like theme color, movies' release year etc.

## Screenshots

![alt text](https://github.com/ludgo/Movies/blob/images/images/movie_grid.jpg "Movie grid")
![alt text](https://github.com/ludgo/Movies/blob/images/images/settings.jpg "Settings")
![alt text](https://github.com/ludgo/Movies/blob/images/images/detail.jpg "Detail")
![alt text](https://github.com/ludgo/Movies/blob/images/images/trailers_reviews.jpg "Reviews and Trailers")

## Acknowledgments

Special thanks to Udacity for providing free access to the course materials prepared in collaboration with Google developer advocates.

## Licence

    Copyright 2016 ludgo

    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.

repository: ludgo/Movies

repo_name: ludgo/Movies


text:
+++
pre = "<b>3.4. </b>"
title = "Governance"
weight = 4
chapter = true
+++

## Background

As the scale of data continues to expand, a distributed approach using multi-node clusters has gradually become a trend. In this case, how to efficiently and automatically manage cluster nodes, realize the collaborative work of different nodes, configuration consistency, state consistency, high availability, observability, etc., has become a challenge.

This section includes three modules: governance, observability and cluster management(in plan).

## Challenges

The challenges of distributed governance mainly lie in the complexity of cluster management and how to connect various third-party integrated components in a unified and standard manner.

The complexity of integrated management is reflected in that on the one hand, we need to manage the status of all nodes in a unified manner and can detect the latest changes in real time, whether it is the underlying database node, middleware or business system node, to further provide the basis for the control and scheduling of the cluster. In this regard, we use the cluster topology state diagram to manage the cluster state and the heartbeat detection mechanism to achieve state detection and update.

On the other hand, the unified coordination and the synchronization of policies and rules between different nodes also require us to design a set of global event notification mechanisms and distributed coordination lock mechanisms for exclusive operations in distributed situations. In this regard, we use Zookeeper/Etcd to achieve configuration synchronization, notification of state changes and distributed locks to control exclusive operations.

At the same time, since the governance function itself can use appropriate third-party components as basic services, we need to abstract a unified interface, unify the standard calling APIs of various components and dock to the governance function module.

Finally, for the requirements of manageability and observability, we need to improve the functions of querying, operating and controlling the system through the UI, further improving the support for tracing and APM.

## Goal

For the governance function, the goals are as follows:

- support Zookeeper/etcd, manage the configuration of data sources, rules and policies, manage the status of each Proxy instances.

For observability, the goals are as follows:

- Support OpenTracing/Skywalking integration and realize call chain tracking.

repository: zoujianchao/shardingsphere

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: zoujianchao/shardingsphere


text:
power-monitor
Repository contains code for a Raspberry Pi running Python3 to connect
to an EKM Omnimeter 1v.3 power monitoring unit and to retrieve power
usage data from that unit. The data is collected at some periodic rate,
initially every minute, and written to adafruit.io to create a power
monitoring dashboard. The data monitored is total kWh consumed, amps
and RMS volts on both lines of a 240V AC service and RMS Watts consumed
on both lines.

The rfomonitoring.py program is set up in init.d so that if the power
is interrupted to the RPi, the restart or reboot will start the program
up again and data will again be collected.

The RPi has a deadman daemon that sends a ping to a watchdog program
every 10 seconds. If enough pings are not received, the watchdog program
resets the RPi, assuming that it is hung in some way.

The rfopower.py program imports the ekmmeters.py library of EKM interface
requests functions, the Adafruit_IO library of API requests to adafruit.io,
and the time and json libraries used to create delays between data reads
and to parse json data from the Omnimeter API calls.

license: MIT

repository: vmoa/rfopower

branch_name: refs/heads/main

repo_name: vmoa/rfopower


text:
asccalc - A Simple Console Calculator

Pretty much a fully featured console calculator. One of the few that makes
it easy to use logic operations and different bases.

Functionality:
==============

Binary Operators
---------
```
+        Addition
-        Subtraction
*        Multiplication
/        Divison
%        Modulo (Remainder)
**       raise to the power of...
^^       same as **
&        Logical And
and      same as &
|        Logical Or
or       same as |
^        Logical Exclusive-Or
xor      same as ^
<<       Logical shift left (arithmetic shift for negative numbers)
>>       Logical shift right (arithmetic shift for negative numbers)
```

Numbers
----------
Numbers can be expressed in many different ways. Here are some examples:

```
0xFF
0b010101
5
0d5
0755
5.71
5.71E-5
5.71p
```

As the last example shows, several SI suffixes are available, with their
usual meaning:

    a,f,p,n,u,m,k,M,G,T,P,E

Comparison Operators (return 1 if true, otherwise 0)
----------
```
>=       Greater or equal
<=       Less or equal
!=       Not equal
==       Equal
>        Greater than
<        Less than
```

Unary Operators
---------
```
-          Unary minus
~          1's complement
!          Factorial
[hi:lo]    Verilog-style part select (select bits from MSB=hi to LSB=lo)
[hi-:cnt]  Verilog-style part select (select cnt bits downwards from MSB=hi)
```

Statements
---------
A statement (i.e. an expression using operators) is evaluated at the
end of the line (e.g. when ENTER is pressed) unless the last character
of the line was a backslash ('\'), in which case the newline is ignored.
Statements can have a trailing semicolon (';') when stand-alone, and must
have a trailing semicolon (';') when they are part of a listing (more on
that later).
Example:

    1 + 5 * 7

or

    1 + 5 * 7;

or

    1 + 5 * \
    7

or

    1 + 5 * \
    7;

User-defined variables
--------
User-defined variables can be created with the following syntax,

    VARIABLE_NAME = STATEMENT

For example,

    x = 5 * pi;

where the trailing semicolon (';') is optional.

Flow control
--------
if/elsif/else and while flow control is available.

The conditional construct if is as follows, where the 'else LISTING' part
is optional,

    if CONDITION then LISTING else LISTING fi

A conditional construct can also contain any number of elsifs:

    if CONDITION then LISTING elsif CONDITION then LISTING else LISTING fi

    if CONDITION then LISTING elsif CONDITION then LISTING elsif CONDITION then LISTING else LISTING fi

For incomplete if statements (i.e. lacking else) a default value of 0 is
returned if no condition matches. Otherwise the value of the last expression
to be evaluated in a LISTING is returned.
The condition can be any statement (see above) that is considered true
if it evaluates to a non-zero value. The LISTING is a series of statements
delimited by a trailing semicolon (';') or other flow control constructs.
After the 'if', a newline can be introduced at any time until the closing
'fi'.
Examples:

    if (x > 5) then
     x/5;
    else
     x*5;
    fi

    if (x > 5)
    then
     x/5;
    fi

The while construct similarly is,

    while CONDITION do LISTING done

A default value of 0 is returned if the condition is false. Otherwise the
value of the last evaluated expression is returned.
The condition can be any statement (see above) that is considered
true if it evaluates to a non-zero value. The LISTING is a series of
statements delimited by a trailing semicolon (';') or other flow control
constructs.
After the 'while', a newline can be introduced at any time until the
closing 'done'.
Examples:

    x = 1;
    while (x < 5) do
     x = x * 2;
    done

User-defined functions
--------
User-defined functions can be defined using the function keyword. The
syntax is as follows:

    function NAME(NAMELIST) = LISTING endfunction

The LISTING is a series of statements delimited by a trailing
semicolon (';') or flow control constructs.
The NAMELIST is a list of comma-separated argument variables to the
function.
After the 'function' token, a newline can be introduced at any time
until the closing 'endfunction'.
All user-defined variables assigned in the body of the function are
local to the function.
The scope inside a function is the global scope and the direct
arguments to the function. It does not include any other scope, e.g.
the scope of the calling function for a nested function.

Example:

    function sum(a,b) =
     a + b;
    endfunction

    function foobar(a,b,c) =
     x = e * a;
     x = sum(x, a);
     root(x, c);
    endfunction

Comments
---------
Comments can either start with // or #

Keywords (i.e. reserved words)
---------
if, then, else, fi, while, do, done, function, endfunction, ls, lsfn,
quit, exit, help, mode, and, or, xor

Commands
---------
```
ls           Lists all variables
lsfn         Lists all functions (builtin and user-defined)
m <mode>     Same as mode <mode>
mode <mode>  Switches to output mode <MODE>, where mode is one of
             the following:
               b - for binary output
               d - for decimal output
	       s - for decimal scientific output
               h or x - for hexadecimal output
               o - for octal output
quit         Exits the program
exit         Exits the program
```

Builtin functions
---------
Check with the 'lsfn' commands for the most up-to-date list.

```
sqrt(a)       Square Root of a
cbrt(a)       Cubic Root of a
root(a,n)     n-th root of a
abs(a)        Absolute value of a
ln(a)         Natural Logarithm of a
log2(a)       Logarithm base 2 of a
log10(a)      Logarithm base 10 of a
exp(a)        exponential of a
sec(a)
csc(a)
cot(a)
cos(a)
sin(a)
tan(a)
acos(a)
asin(a)
atan(a)
atan2(y,x)
cosh(a)
sinh(a)
tanh(a)
sech(a)
csch(a)
coth(a)
acosh(a)
asinh(a)
atanh(a)
erf(a)        Error function of a
erfc(a)       Complementary error function of a
hypot(x,y)    Hypotenuse of x and y, i.e. sqrt(x^2 + y^2)
round(a)      Round a to nearest integer
ceil(a)       Round a upwards to nearest integer
floor(a)      Round a downwards to nearest integer
trunc(a)      Truncate a to an integer
int(a)        Same as trunc(a)
nextprime(a)  Gives the next highest prime number after a
gcd(a,b)      Greatest common divisor of a and b
lcm(a,b)      Least common multiple of a and b
remfac(a,b)   Remove factor b from a
bin(a,b)      Binomial coefficient (a | b)
fib(n)        n-th fibonacci number
inv(a,N)      Find the inverse of a (modulo N)
hamdist(a,b)  Gives the hamming distance between integers a and b
countones(a)  Returns the number of 1-bits in integer a
popcount(a)   Same as countones(a)
popcnt(a)     Same as countones(a)
min(a,b,...)  Minimum of a,b,...
max(a,b,...)  Maximum of a,b,...
avg(a,b,...)  Average of a,b,...
tabulate(f,a,b,...) Print the result of applying function f to a, b, ... as a table
```

Build and Install
=============

Dependencies
-------------
```
flex (build only)
bison (build only)
libmpfr
libgmp
```

To build on Ubuntu and Debian:

    apt-get install flex bison libmpfr-dev libgmp-dev make gcc

To just use a binary package:

    apt-get install libgmp10 libmpfr4

Build
------------
Just type

    make

repository: bwalex/asccalc

repo_name: bwalex/asccalc


text:
@typedef {Object} can-stache.helperOptions helperOptions
@parent can-stache.types

@description The options argument passed to a [can-stache.helper helper function]
when called by a [can-stache/expressions/helper].

@type {Object}

When a [can-stache.helper helper function]
is called by a [can-stache/expressions/helper], a `helperOptions`
object is passed with the following properties:

```js
stache.registerHelper( "myHelper", function( helperOptions ) {
	helperOptions.fn;      //-> sectionRenderer(){}
	helperOptions.inverse; //-> sectionRenderer(){}
	helperOptions.hash;    //-> Object
	helperOptions.context; //-> *
	helperOptions.scope;   //-> Scope
	helperOptions.option;  //-> Scope.Options
} );
```

  @option {can-stache.sectionRenderer} [fn] Renders the "truthy" subsection
  BLOCK.  `options.fn` is only available if the helper is called as a
  [can-stache.tags.section] or [can-stache.tags.inverse]. Read about
  [can-stache.sectionRenderer section renderer] for more information.

  @option {can-stache.sectionRenderer} [inverse] Renders the "falsey" subsection
  INVERSE.  `options.inverse` is only available if the helper is called as a
  [can-stache.tags.section] or [can-stache.tags.inverse] and [can-stache.helpers.else]
  is used. Read about
  [can-stache.sectionRenderer section renderer] for more information.

  @option {Object} hash An object containing all of the
  [can-stache.expressions Hash expression] keys and values. For example:

  ```html
  {{helper arg1 arg2 name=value other=3 position="top"}}
  ```

  might provide a `hash` like:

  ```js
  {
	name: compute( "Mr. Pig" ),
	other: 3,
	position: "top"
}
```

  @option {*} context The current context the stache helper is called within. Read
  [can-stache.scopeAndContext] for more information.

@option {can-view-scope} scope An object that represents the current context and all parent
contexts. It can be used to look up [can-stache.key key] values in the current scope.
Read [can-stache.scopeAndContext] and [can-view-scope] for more information.

@option {can-view-scope.Options} options It can be used to look up [can-stache.key key] values in the current options scope.
Read [can-stache.scopeAndContext] and [can-view-scope.Options] for more information.

repository: canjs/can-stache

gha_language: JavaScript

gha_license_id: MIT

repo_name: canjs/can-stache


text:
# BlogNode

Simple CMS with Node and Express

## Getting Started

Building a Simple Blog With Node, Express & NeDb. My first approach with Node left me confused. So I started studying Express and REST architecture for a test bench: a trivial CMS.

In public folder, index.html load the API with async function (list of posts in JSON). Login.html verifies the credentials and save the JWT in local storage. Dashboard.html and handle.html for write new post and update olds.

Article.js is the router for article mini app. Auth.js handles the credentials and permissions and Api.js... yes.

I have not used a template for the views and the user experience sucks. But Vue, with Axios, can make it better.

### Prerequisites

```
npm install express
npm install body-parser
npm install jsonwebtoken
npm install nedb
npm install helmet
```

### Installing

git clone https://github.com/sam-sepi/BlogNode.git

## Built with

[Node](https://nodejs.org/en/)

[Express](https://expressjs.com/)

## Authors

Sam Sepi -<EMAIL_ADDRESS>
## License

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

repository: sam-sepi/BlogNode

gha_language: HTML

repo_name: sam-sepi/BlogNode


text:
# Workshop Curriculum

### Clojure Basics
* Writing simple expressions; prefix notation; introduce the idea of forms/s-expressions
* primitives: numbers, keywords, strings, booleans, nil
* Collection literals: lists, vectors, maps, sets
* Name things using def
* The idea of 'var's - and the idea of interning, namespaces and bindings
 - And why 'def' is to be used with care, and at the top level (conventionally)
* Define basic functions with defn
* conditionals with if; truthiness and falsiness
* bindings with let
* collections: vectors, maps, sets. Introduce the ideas of immutability and persistent data structures
* destructuring with let

### Working with functions
* Defining and calling functions
* multi-arity functions
* varargs
* destructuring
* pre/post conditions
* operating on functions: partial, comp, juxt
* anonymous functions and closures
* higher-order functions: map, filter, reduce

### Project Management
* namespaces and organising clojure code
* introduce leiningen
* setting up a project with lein new
* adding a dependency using lein, and requiring it in a namespace

### Sample project
* TBD -- this is still under discussion.

repository: inclojure-org/organization

repo_name: inclojure-org/organization


text:
---
layout: post
title: Travis-ci - deployment triggers
description: "Deploy your code only for specified branch and all tests are passing"
modified: 2016-09-26T05:35:00-04:00
tags<EMAIL_ADDRESS>emberjs, ember-cli-deploy, github pages, travis-ci, triggers, continuous deployment]
---

### Description
We need to deploy our Emberjs application when:

* code is pushed/merged into **deployment** branch.
* all acceptance tests succeed.

### End Goal

```yml
before_deploy:
  - ember test -f 'Acceptance |'
deploy:
  skip_cleanup: true
  provider: script
  script: ember deploy testing --verbose
  on:
    branch: deployment
```

### Step by step

* Setup deployment trigger

```yml
deploy:
  on:
    branch: deployment
```

* Run the acceptance tests

```yml
before_deploy:
  - ember test -s -f 'Acceptance |'
```

* Add the deployment command

```yml
deploy:
  provider: script
  script: ember deploy testing --verbose
```

* Complete travis config file

```yml
---
language: node_js
node_js:
  - "4.5.0"

sudo: false

cache:
  directories:
    - node_modules

before_install:
  - export PATH=/usr/local/phantomjs-2.0.0/bin:$PATH
  - "npm config set spin false"
  - "npm install -g npm@^2"

install:
  - npm install -g bower
  - npm install
  - bower install

script:
  - npm test

before_deploy:
  - ember test -s -f 'Acceptance |'
deploy:
  skip_cleanup: true
  provider: script
  script: ember deploy testing --verbose
  on:
    branch: deployment
```

Now you can do this!

### GitHub resources:
* [Travis config file](http://nshimiye.com/tutorial-ember-cli-1.13.14/tests/?testId=6c41b476)

<!-- {% gist mmistakes/6589546 %} -->

repository: marcellin-me/blog

repo_name: marcellin-me/blog


text:
# bender

Bender is a dependency management tool for hardware design projects. It provides a way to define dependencies among IPs, execute unit tests, and verify that the source files are valid input for various simulation and synthesis tools.

[![Build Status](https://travis-ci.org/fabianschuiki/bender.svg?branch=master)](https://travis-ci.org/fabianschuiki/bender)
[![Crates.io](https://img.shields.io/crates/v/bender.svg)](https://crates.io/crates/bender)

## Workflow

The workflow of bender is based on a configuration and a lock file. The configuration file lists the sources, dependencies, and tests of the package at hand. The lock file is used by the tool to track which exact version of a package is being used. Adding this file to version control, e.g. for chips that will be taped out, makes it easy to reconstruct the exact IPs that were used during a simulation, synthesis, or tapeout.

Upon executing any command, bender checks to see if dependencies have been added to the configuration file that are not in the lock file. It then tries to find a revision for each added dependency that is compatible with the other dependencies and add that to the lock file. In a second step, bender tries to ensure that the checked out revisions match the ones in the lock file. If not possible, appropriate errors are generated.

The update command reevaluates all dependencies in the configuration file and tries to find for each a revision that satisfies all recursive constraints. If semantic versioning is used, this will update the dependencies to newer versions within the bounds of the version requirement provided in the configuration file.

## Package Structure

Bender looks for the following three files in a package:

- `Bender.yml`:

  This is the main package manifest, and the only required file for a directory to be recognized as a Bender package. It contains metadata, dependencies, and source file lists.

- `Bender.lock`:

  The lock file is generated once all dependencies have been successfully resolved. It contains the exact revision of each dependency. This file *may* be put under version control to allow for reproducible builds. This is handy for example upon taping out a design. If the lock file is missing or a new dependency has been added, it is regenerated.

- `Bender.local`:

  This file contains local configuration overrides. It should be ignored in version control, i.e. added to `.gitignore`. This file can be used to override dependencies with local variants. It is also used when the user asks for a local working copy of a dependency.

## Targets

Targets are flags that can be used to filter source files and dependencies. They are used to differentiate the step in the ASIC/FPGA design flow, the EDA tool, technology target, etc. The following table lists the targets that should be adhered to:

- `test`: Set this target when verifying your design through unit tests or testbenches. Use the target to enable source files that contain testbenches, UVM models, etc.

- **Tool**: You should set exactly one of the following to indicate with which tool you are working.

  - `vsim`: Set this target when working with ModelSim vsim. Automatically set by the *bender-vsim* plugin.

  - `vcs`: Set this target when working with Synopsys VCS. Automatically set by the *bender-vcs* plugin.

  - `synopsys`: Set this target when working with Synopsys Design Compiler. Automatically set by the *bender-synopsys* plugin.

  - `vivado`: Set this target when working with Xilinx Vivado. Automatically set by the *bender-vivado* plugin.

  - `riviera`: Set this target when working with Aldec Riviera-PRO.

- **Abstraction**: You should set exactly one of the following to indicate at which abstraction level you are working on.

  - `rtl`: Set this target when working with the Register Transfer Level description of a design. If this target is set, only behavioural and no technology-specific modules should be used.

  - `gate`: Set this target when working with gate-level netlists, for example after synthesis or layout.

- **Stage**: You should set exactly one of the following to indicate what you are using the design for.

  - `simulation`: Set this target if you simulate the design. This target should be used to include protocol checkers and other verification modules.

  - `synthesis`: Set this target if you synthesize the design. The target can be used to disable various parts of the source files which are not synthesizable.

- **Technology**: You should set exactly one of the following pairs of targets to indicate what FPGA or ASIC technology you target.

  - `fpga xilinx`
  - `fpga altera`
  - `asic umc65`
  - `asic gf28`
  - `asic gf22`
  - `asic stm28fdsoi`

repository: SamuelRiedel/bender

gha_license_id: NOASSERTION

repo_name: SamuelRiedel/bender


text:
# passport-picsart

[![Build](https://travis-ci.org/PicsArt/passport-picsart.png)](http://travis-ci.org/PicsArt/passport-picsart)
[![Dependencies](https://david-dm.org/PicsArt/passport-picsart.png)](http://david-dm.org/PicsArt/passport-picsart)

[Passport](http://passportjs.org/) strategy for authenticating with [PicsArt](http://www.picsart.com/)
using the OAuth 2.0 API.

This module lets you authenticate using PicsArt in your Node.js applications.
By plugging into Passport, PicsArt authentication can be easily and
unobtrusively integrated into any application or framework that supports
[Connect](http://www.senchalabs.org/connect/)-style middleware, including
[Express](http://expressjs.com/).

## Install

    $ npm install passport-picsart

## Usage

#### Configure Strategy

The PicsArt authentication strategy authenticates users using a PicsArt account
and OAuth 2.0 tokens.  The strategy requires a `verify` callback, which receives the
access token and corresponding secret as arguments, as well as `profile` which
contains the authenticated user's PicsArt profile.   The `verify` callback must
call `done` providing a user to complete authentication.

In order to identify your application to PicsArt, specify the client ID,
client secret, and callback URL within `options`.  The client ID and secret
are obtained by [creating an application](https://dev.picsart.com/apps) at
PicsArt's [developer](https://dev.picsart.com/) site.

    passport.use(new PicsartStrategy({
        clientId: PICSART_CLIENT_ID,
        clientSecret: PICSART_CLIENT_SECRET,
        callbackURL: "http://<IP_ADDRESS>:3000/auth/picsart/callback"
      },
      function(accessToken, profile, done) {
        User.findOrCreate({ picsartId: profile.id }, function (err, user) {
          return done(err, user);
        });
      }
    ));

#### Authenticate Requests

Use `passport.authenticate()`, specifying the `'picsart'` strategy, to
authenticate requests.

For example, as route middleware in an [Express](http://expressjs.com/)
application:

    app.get('/auth/picsart',
      passport.authenticate('picsart'));

    app.get('/auth/picsart/callback',
      passport.authenticate('picsart', { failureRedirect: '/login' }),
      function(req, res) {
        // Successful authentication, redirect home.
        res.redirect('/');
      });

## License

[The MIT License](http://opensource.org/licenses/MIT)

Copyright (c) 2015 PicsArt <[http://www.picsart.com/](http://www.picsart.com/)>

repository: PicsArt/passport-picsart

repo_name: PicsArt/passport-picsart


text:
# INSTALL

## Quick Install

    cmake -S . -B build -DCMAKE_INSTALL_PREFIX=/usr/local
    cmake --build build --target install

CMake defaults CMAKE\_INSTALL\_PREFIX to sane values for most platforms.

If the installed version of cmake is too old for the -S and -B options then it
is highly recommended that you first update cmake.

## Packages

    cmake --build build --target package

To control what format package(s) are created: set CPACK\_BINARY\_\<GEN\> for
the CPACK\_GENERATORs you want to enable or disable. CMake's defaults depend on
the host environment.

## CMake Presets

A recent version of CMake is required to use presets.

    cmake --list-presets
    Available configure presets:

    "Linux"   - Linux Development
    "Windows" - Windows Development
    "Package" - Create Packages

    cmake --preset Windows
    cmake --build --preset Windows

Read CMakePresets.json for more details on individual presets.  These configure
presets expect to VCPKG\_ROOT to be set before runing cmake.

## Using vcpkg

Set VCPKG\_ROOT before running cmake.

### Setup

    git clone  https://github.com/microsoft/vcpkg.git

    .\vcpkg\bootstrap-vcpkg.sh
    export VCPKG_ROOT=${PWD}/vcpkg

    OR

    .\vcpkg\bootstrap-vcpkg.bat
    SET VCPKG_ROOT=%CD%\vcpkg

### Configuration

Since manifest mode is used once VCPKG_ROOT is setup: the rest is taken care of
by the toolchain file.  Configure cmake using CMAKE\_TOOLCHAIN\_FILE when
configuring or use a CMake Preset.

    cmake -B build -S . -DCMAKE_TOOLCHAIN_FILE=${VCPKG_ROOT}/scripts/buildsystems/vcpkg.cmake

    OR

    cmake -B build -S . -DCMAKE_TOOLCHAIN_FILE=%VCPKG_ROOT%\scripts\buildsystems\vcpkg.cmake

When ENABLE_REDIST=ON (default), the install and package targets will include
the dependencies from VCPKG_ROOT. Be aware of that if you are disabling
VCPKG_MANIFEST_MODE and using a large VCPKG_ROOT shared by multiple projects.

license: ISC


text:
---
title: Sunsetting Doctrine DBAL 2
authorName: Sergei Morozov
authorEmail<EMAIL_ADDRESS>permalink: /2022/01/22/sunsetting-dbal-2.html
---

Since the release of [Doctrine DBAL 3.0.0 ](https://github.com/doctrine/dbal/releases/tag/3.0.0) in November 2020,
the 2.x release series effectively went into the maintenance mode. In the past year, we've been accepting mostly
the following types of patches for DBAL 2:

1. Development dependency updates
2. Security fixes
3. Improvements to compatibility with PHP 8.1
4. Improvements in the upgrade path to DBAL 3

Except for dependency updates, at the moment, there are no known issues in DBAL 2 that would fall into any of
the above categories.

Many projects that depend on Doctrine DBAL depend on it indirectly via Doctrine ORM which until
[release 2.10.0](https://github.com/doctrine/orm/releases/tag/2.10.0) didn't support DBAL 3.
It was one of the blockers of the DBAL 3 adoption which is no longer the case.

With all that said, the DBAL team announces the plan for sunsetting DBAL 2 in 6 months as of the ORM 2.10.0 release
which is April 3, 2022. After that date, we plan to release DBAL 2 only to address security related
and other critical issues for at most a year.

All Doctrine DBAL users are encouraged to upgrade to the latest stable version
which is [3.3.0](https://github.com/doctrine/dbal/releases/tag/3.3.0) as of the time of this writing.

For migrating from DBAL 2 to 3, see our two blog posts on DBAL 2.13 Forward Compatibility Layer:

- [New Release: Doctrine DBAL 2.13 with Deprecations and Forward Compatibility](https://www.doctrine-project.org/2021/03/29/dbal-2.13.html)
- [New Release: Doctrine DBAL 2.13.1 and 3.1.0 with important Forward Compatibility fix](https://www.doctrine-project.org/2021/04/19/dbal-2.13.1-3.1.0.html)

repository: doctrine/doctrine-website

gha_language: PHP

repo_name: doctrine/doctrine-website


text:
# zhang18-data

RDF Version of Zhang18 data

Starting with announcement of this study: <https://credibilitycoalition.org/results/>

I wrote some code to convert the data into a format I think might be better.

More details on what I did in [NOTES.md]().

* out.trig is the RDF output
* all-records.json is an intermediate form
* part1.js produces that intermediate form
* the library itself gives you a kgx kb object (which is an n3.store),
  if you prefer:

```js
const zd = require('zhang18-data')

console.log(zd.kb.countQuads())
```


text:
# VerifiableCredential Service

A HTTP service that wraps [vc-sdk](https://github.com/medibloc/vc-sdk)

## Features

- Sign credentials

### TODO
- Verify credentials
- Sign presentations
- Verify presentations

## Building and Running

### Without Docker
```bash
go build ./...

### Responses

|Status Code|Description|
|-----------|-----------|
|201|Credential successfully issued|
|400|Invalid input|
|500|Internal error|

repository: medibloc/vc-service

gha_language: Go

repo_name: medibloc/vc-service


text:
# LP-3D
Python implementation of Expanding Label Sets for Graph Convolutional Networks written by Mustafa Coskun and submitted to PeerJ Computer Science

Requirements

Python 3

tensorflow

networkx

scikit-learn

Run
TestAlphaEffect.py

Configuration
See config.py file

For any question email me via<EMAIL_ADDRESS>
Cite
@article{coskun2019expanding,
  title={Expanding Label Sets for Graph Convolutional Networks},
  author={Coskun, Mustafa and Gungor, Burcu Bakir and Koyuturk, Mehmet},
  journal={arXiv preprint arXiv:1912.09575},
  year={2019}
}


text:
# A Julia Package for Inter-Process Communication

Julia has already many methods for inter-process communication (IPC): sockets,
semaphores, memory mapped files, etc.  You may however want to have Julia
interacts with other processes or threads by means of BSD (System V) IPC or
POSIX shared memory, semaphores, message queues or mutexes and condition
variables.  Package `InterProcessCommunication.jl` intends to provide such
facilities.

The statement `using InterProcessCommunication` exports (among others)
a shortcut named `IPC` to the `InterProcessCommunication` module.
This documentation assumes this shortcut and the prefix `IPC.` is used
in many places instead of the much longer `InterProcessCommunication.`.

The code source of `InterProcessCommunication.jl` is
[here](https://github.com/emmt/InterProcessCommunication.jl).

```@contents
Pages = ["semaphores.md", "sharedmemory.md", "reference.md"]
```

## Index

```@index
```

gha_language: Julia


text:
---
uid: omfIngressSubscriptions
---

# Subscriptions (legacy)

**Note:** OMF topics and subscriptions have been replaced by <xref:omf-ingress-omf-connections>. See <xref:OMFmigration>.

A subscription consumes OMF messages from a topic and forwards them to a data store. Multiple subscriptions can retrieve OMF messages from a single *topic*.

There are two types of subscriptions with different behaviors.

- Standard subscription – A standard subscription provides an endpoint for an external application to query. It maintains a bookmark into the topic queue and serves up data in sequence. Standard
subscriptions are not yet supported.

- Sequential Data Store subscription – A Sequential Data Store subscription retrieves data from a topic and writes it directly to a namespace in the Sequential Data Store.

## Subscription information

A subscription can consume OMF messages from a *topic* in a different *namespace*; however, the topic's namespace must be in the same region as the subscription's namespace.

OMF messages that the subscription is processing are temporarily stored in the region of its namespace.
An OMF Subscription retrieves OMF messages from a topic and writes them directly to a namespace in the Sequential Data Store.

Currently only OMF subscriptions are supported. The documentation uses OMF subscription and subscription interchangeably.

## Subscriptions API

- [Subscriptions](xref:omf-ingress-subscriptions)

repository: osisoft/OCS-Docs

repo_name: osisoft/OCS-Docs


text:
# Welcome to the  Scripting Reference!

This section of the documentation contains the details of the scripting API of the
JCSUE. To use this information, you should be familiar with Unreal Scripting API
and the concept of the basic game engine architecture.

This scripting reference is layouted corresponding to JCSUE scripts
section under
[JCSUE sources folder](https://github.com/jcs090218/JCSUE/tree/master/Plugins/JCSUE_Plugin/Source/JCSUE_Plugin).
In addition, is organized according to the classes avaliable to scripts which
are described along with their variables, functions and any other relevant
information to use.

The pages contain example code ("examples") if necessary to describe the scripting
reference usage. JCSUE does only uses 'JCSUE' as the only namespace in this
tool within the code. Scripts that are not prefix with JCS underscore it could be
utility scripts that JCSUE include and ensure the utility script itself is free
to use.


text:
# MOVED

Further development of *browserify-rails* is now a community effort in the
[browserify-rails organization repo](https://github.com/browserify-rails/browserify-rails). Please
file issues at and send pull requests to the new repository.

# browserify-rails

[![Build Status](https://travis-ci.org/hsume2/browserify-rails.png?branch=master)](https://travis-ci.org/hsume2/browserify-rails)

This library adds CommonJS module support to Sprockets (via Browserify).

It let's you mix and match  `//= require` directives and `require()` calls for including plain javascript files as well as modules.

1. Manage JS modules with `npm`
2. Serve assets with Sprockets
3. Require modules with `require()` (without separate `//= require` directives)
4. Only build required modules
5. Require *npm modules* in your Rails assets

## Getting Started

Add this line to your application's Gemfile:

    gem "browserify-rails", "~> 0.3"

Create `package.json` in your Rails root:

```js
{
  "name": "something",
  "devDependencies" : {
    "browserify": "~> 4.1"
  },
  "license": "MIT",
  "engines": {
    "node": ">= 0.10"
  }
}
```

Then run:

    npm install

Then start writing CommonJS, and everything will magically work!:

```js
// foo.js
module.exports = function (n) { return n * 11 }

// application.js
var foo = require('./foo');
console.log(foo(12));
```

## CoffeeScript

For CoffeeScript support, make sure to follow the standard rails
`.js.coffee` naming convention.  You'll also need to do the following:

Add `coffeify` as a dependency within `package.json`:

```js
{
  // ...
  "devDependencies" : {
    // ...
    "coffeeify": "~> 0.6"
  }
}
```

Add the following command line options within `application.rb`:

```rb
config.browserify_rails.commandline_options = "-t coffeeify --extension=\".js.coffee\""
```

## Configuration

You can configure different options of browserify-rails by adding one of lines
mentioned below into your `config/application.rb` or your environment file
(`config/environments/*.rb`):

```ruby
class My::Application < Rails::Application
  # Paths, that should be browserified. We browserify everything, that
  # matches (===) one of the paths. So you will most likely put lambdas
  # regexes in here.
  #
  # By default only files in /app and /node_modules are browserified,
  # vendor stuff is normally not made for browserification and may stop
  # working.
  config.browserify_rails.paths << /vendor\/assets\/javascripts\/module.js/

  # Environments, in which to generate source maps
  #
  # The default is `["development"]`.
  config.browserify_rails.source_map_environments << "production"

  # Command line options used when running browserify
  #
  # can be provided as an array:
  config.browserify_rails.commandline_options = ["-t browserify-shim", "--fast"]

  # or as a string:
  config.browserify_rails.commandline_options = "-t browserify-shim --fast"
```

## Contributing

Pull requests appreciated.

## Contributors

* [Henry Hsu](https://github.com/hsume2)
* [Cássio Souza](https://github.com/cassiozen)
* [Marten Lienen](https://github.com/CQQL)
* [Lukasz Sagol](https://github.com/zgryw)

gha_language: Ruby


text:
---
layout: page
title: About OpenVnmrJ
tags: [about, OpenVnmrJ]
modified: 2014-08-08T20:53:07.573882-04:00
comments: true
image:
  feature: sample-image-2.jpg
  credit: WeGraphics
  creditlink: http://wegraphics.net/downloads/free-ultimate-blurred-background-pack/
---

##Who we are##

The OpenVnmrJ project as a community revolves around OpenVnmrJ as a piece of software. OpenVnmrJ resulted from the open-source release of formerly commercial software for running NMR spectrometers (VnmrJ). We are a group of NMR spectroscopists and open-source developers who develop, use, document, and promote OpenVnmrJ running on NMR spectrometers and data stations, as well as other related activities for our mutual benefit.

See "OpenVnmrJ Background" for more information

##OpenVnmrJ##

OpenVnmrJ is the open source parts of VnmrJ 4.2, used for NMR Data processing and acquisition. The software runs on Linux: Centos 6 and Ubuntu 14.02, Trusty Tahr are the currently targeted hosts. As a datastation, the software runs on OS X 10.09 to 10.11.

OpenVnmrJ is designed to be very extensible with:
- A rich set of macros, written in MAGICAL
- A very configurable interface, using XML assets
- A comprehensive library of pulse programs, written in C, usually with added macros and XML files to ease setting up experiments and processing of data

All of this is now open sourced and needs your help to maintain code, fix bugs, add new features, and improve the user experience for all users of OpenVnmrJ.

##Using repository##
This repository is for people that want to download, compile, fix and contribute back to the community.

If you only want to download and run OpenVnmrJ, you should get a pre-built archive and install a local copy. See Downloading.md for more information.

## Spectrometer users, read this ##
** Do not delete the Agilent supplied VnmrJ on your spectrometer **
* Agilent service requires VnmrJ 4.2
* The low-level spectrometer console software is NOT open sourced

##Contributing##
See the file Contributing.md to get started.

## Owner ##
The Board of Trustees of the University of Oregon ("University of Oregon") legally owns the project assets and has licensed OpenVnmrJ as open source software.

##License##
Most of the code and documentation are licnesed under the Apache 2.0 license, but some parts are licensed under the GLPv3 license.
See the License.md file for more information.

##Disclaimer##
To the fullest extent allowed by law, the work is provided "as-is" with no warrantees whatsoever, either expressed or implied, oral or written. Agilent specifically disclaims any warrantees of merchantability or fitness for a particular purpose. This work is not a manufacturer's release version. All disputes will be heard in the courts of California.

repository: ekpaulson/website-alt

repo_name: ekpaulson/website-alt


text:
## [MODULE HAL.i64.qemu](https://github.com/io-core/Boot/blob/main/HAL.i64.qemu.Mod)
The HAL prepares the Oberon runtime and so cannot rely on it.

* No global variables
* No strings
* No heap allocation

The first thing HAL must do is set up its own stack.

Each platform should have its own HAL. This is the HAL for x86_64 on QEMU.

The HAL remains resident and may be used by other modules.

  ## Imports:
` SYSTEM`

## Constants:
```

    rsData = -56;
    rsCtrl = -52;

```
## Types:
```

```
## Variables:
```

```
## Procedures:
---
---
**Init** simply returns.

`PROCEDURE Init( i: INTEGER);` [(source)](https://github.com/io-core/Boot/blob/main/HAL.i64.qemu.Mod#L35)

---
**The initialzation code for this module** calls Init and then goes into an infinite loop.

repository: io-core/Doc

repo_name: io-core/Doc


text:
# Project Templates (boilerplate) Manager
Project Templates Manager is a tool to help create new projects from boilerplate. It preprocess code and setup it to your needs, for example author name and email, license etc.

## Why not CookieCutter
There is another great tool to generate python (ant other languages) boilerplate https://github.com/audreyr/cookiecutter but it does not give you freedom with implementing new ways to create results (except pre and post scripts). With PTM you could implement your own factories easly, for example: fetch from GIT, FTP, email, etc. (btw. GIT will be implemented soon)

## Requirements
Project Templates Manager requires click, pyyaml and Jinja2

## Getting It
You can get Project Templates Manager from GitHub and run `setup.py`:

    $ git clone git://github.com/GrivIN/ptm.git
    $ cd ptm
    $ python setup.py install

## Getting Started
Project Templates Manager is a command line tool, to print help type `ptm` or `ptm [COMMAND] --help` to get command specific help.

Before first user set up your own context variables by copying `ptm/config/settings.example.yaml` to your home directory and change values privided by example to you own.

    $ cp ptm/config/settings.example.yaml ~/.ptm-settings.yaml
    $ nano ~/.ptm-settings.yaml

### Start new project
To create new project go to your projects directory (ex. `~/work/projects/`) and type

    $ ptm create [OPTIONS] APP_NAME [MAINTYPE] [SUBTYPE]

`[MAINTYPE]` and `[SUBTYPE]` are optional and if not given defaults from settings file will be used. To see all available type `ptm list`:

    $ ptm list
    django110:
    	app - ([...]/ptm/templates/django110/app)
    	project - ([...]/ptm/templates/django110/project)
    python:
    	app - ([...]/ptm/templates/python/app)

### Setup
You could have up to 4 settings files:
- `ptm/config/defaults.yaml`
- `~/.ptm-settings.yaml`
- `.ptm-settings.yaml` in current directory
- settings file pointed by `--settings` option

Those files are readed in above order and if variable is given in more than one last occurence will be used. Aditionaly `context` variables could be updated by `get_context` method in `[MAINTYPE]/factory.py`

### Create new boilerplate template
To add new boilerplate templates into system, setup `templates` variable in `~/.ptm-settings.yaml` by adding full path to directory (could handle multiple locations) contain additional templates.
- Create subdirectory with yours `[MAINTYPE]` name.
- Create subdirectory inside `[MAINTYPE]` dir with `[SUBTYPE]` as a name, it will contain your boilerplate files. Files without `.ptmt` extension will be not processed by Jinja2 template system.
- Create `factory.py` file inside `[MAINTYPE]` dir with minimal contents:

```python
from ptm.factories.base import TemplatedAppFactory

class AppFactory(TemplatedAppFactory):
    def get_context(self, settings_context):
        return super().get_context(settings_context)

    def run(self):
        return super().run()

```
- run `ptm list` to check you new template is visible.

### Add new context variables

#### Static variables
To set up new context variable you could use `~/.ptm-settings.yaml` for global usage, or `.ptm-settings.yaml` in current directory to company/project specific variables

#### Dynamic variables
To change or add new dynamic context variables you have to create your own factory and overwrite `get_context` method. Check `ptm/templates/django110/factory.py` for more details.

repository: GrivIN/ptm

gha_language: Python

repo_name: GrivIN/ptm


text:
## Inverse Cumulative Palindrome

### A simple program to solve an interesting problem.

Problem statement goes below.

- You are given a number e.g 67. You have to check whether its palindrome or not.
- If yes , problem ends here.
- If not , you have to find a number that is fornt digit rear to the given number , such as 67 is the given number and 76 is resultant.
- Now you have to find the sum of those two numbers and check if its palindorme or not. (For the sake of explanation 67 + 76 = 143 which is not a palindrome.)
- If not , repeat the the whole process from the first step with the sum until you come up with a palindorme number.

### This is what I solved using C#.

![solve](https://github.com/evilprince2009/Inverse-Cumulative-Palindrome/blob/main/Images/Screenshot_1.png)

## Limitations

I wans't able to find a result for those two numbers below using this program.

- 196
- 788


text:
---
id: getting-started/install-configure
title: Installation
redirect_from: "docs/index.html"
layout: docs
---

There are currently two options for installing and working with **Stylable** as described in the following sections.

## Write your own project based on a Stylable boilerplate

To begin writing your own project, you can create a **Stylable** app from our boilerplate. It is based on [create-react-app](https://github.com/facebookincubator/create-react-app). To create the project, follow these instructions:

Using npm:
```bash
npm install -g create-react-app

create-react-app my-app-name --scripts-version stylable-scripts
```
For the `my-app-name` value above, replace with the name of your project. Once you run the command, a directory with that same name is created. Go to that directory and run `yarn start` or `yarn build` to create the project in a browser.

The project includes several basic components and **Stylable** stylesheets which have the suffix `.st.css`.

## Install Stylable to work with an existing project

To work with an existing project, you can install **stylable** and the **stylable-integration** packages from our GitHub [repository](https://github.com/wix/stylable).

Install **stylable** and **stylable-integration** as a dependency in your local project.

Using npm:
```bash
npm install stylable stylable-integration --save-dev
```
Using Yarn:
```bash
yarn add stylable stylable-integration
```

## Write in Stylable

Once you've installed either the boilerplate or the packages into your own project, you can begin writing in **Stylable**. Look through the [Specifications Reference](./cheatsheet.md) for specs and code examples.

To take advantage of code completion and diagnostics, install [**Stylable Intelligence**](./stylable-intelligence.md) currently supported for only Visual Studio Code (version 1.16 and later).

## Build configuration

Currently we support Webpack as our build system. To author a component library, use our CLI tool to build each CSS separately.

Add **Stylable** to your Webpack configuration as follows:

```
const StylablePlugin = require('stylable-integration/webpack-plugin');
...
{
    module: {
        rules: [
            StylablePlugin.rule(),
            // to load CSS assets from bundle we need the url loader configured.
            // example configuration
            {
                test: /\.(png|jpg|gif|svg)$/,
                use: [
                    {
                        loader: 'url-loader',
                        options: {
                            limit: 8192
                        }
                    }
                ]
            }
        ]
    },
    plugins: [
        new StylablePlugin({ injectBundleCss: true  /* dev mode */ })
    ]
}
```

For a production build, you should not use the `injectBundleCss` option. The project creates a bundle CSS asset in your output directory. Just load this into your html. You can set the file name. For details, see [**stylable-integration**](https://github.com/wix/stylable-integration).

repository: mattdanielbrown/stylable

gha_language: TypeScript

repo_name: mattdanielbrown/stylable


text:
# Building A Platform

You have an EDK2 implementation, a platform DSC, and a platform FDF? Great! You
are one [settings file](/features/settings_manager) away from a great
platform building experience.

The build process has three [stuart commands](/#what-can-i-ask-stuart-to-do)
to take your firmware code tree from freshly cloned to fully built: `stuart_setup`, `stuart_update`, `stuart_build`
(hereby known has the "command(s)"). Behind the scenes, each command is an [Invocable](/features/invocable)
that has a corresponding [Settings Manager](/features/settings_manager) that the platform subclasses to provide
platform specific information.

In hopes of keeping this section as light as possible, the information provided will be broad and more conversational
then tutorial. If you want a step by step example of porting a platform, we have one! Please see
[Porting the Raspberry Pi 3](/integrate/porting).

## Getting Started

Stuart needs a settings file to configure itself. This settings file must provide a settings manager subclasses for each
command you plan on using. This settings manager is the interface that provides platform specific information to the
platform agnostic invocable. This is done via subclassing the corresponding settings file and overriding the necessary
methods described in the [Settings Manager](/features/settings_manager).

In terms of building a platform, there are five classes that you need to be aware of. The first two are interfaces that
provide functions used across all three commands and can be shared among the SettingsManagers by using
[Multiple Inheritance](/features/settings_manager/#a-note-on-multi-inheritance).

1. [Edk2InvocableSettingsInterface](/api/edk2_invocable/#edk2toolext.edk2_invocable.Edk2InvocableSettingsInterface)
2. [MultiPkgAwareSettingsInterface](/api/invocables/edk2_multipkg_aware_invocable/#edk2toolext.invocables.edk2_multipkg_aware_invocable.MultiPkgAwareSettingsInterface)
3. [SetupSettingsManager](/api/invocables/edk2_setup/#edk2toolext.invocables.edk2_setup.SetupSettingsManager)
4. [UpdateSettingsManager](/api/invocables/edk2_update/#edk2toolext.invocables.edk2_update.UpdateSettingsManager)
5. [BuildSettingsManager](/api/invocables/edk2_ci_build/#edk2toolext.invocables.edk2_ci_build.CiBuildSettingsManager)

The final class we inherit from in the settings file the
[UefiBuilder](/api/environment/uefi_build/#edk2toolext.environment.uefi_build.UefiBuilder)
and is what provides the bulk of customization EDK2 Pytools affords you.
This is also where you can utilize many of the features and functionality
spread across Edk2-Pytools (Extensions and Library).

Lets take a look at each command!

## Stuart Setup

`stuart_setup` is the first command and is responsible for setting up the code tree. Currently, this only involves
preparing the git submodules necessary for build. If you've created an [Omnicache](/tools/using_omnicache_tool/), here
is where you would use it to save on network bandwidth, disk space, and time when cloning repos. As you might expect,
`stuart_setup` does not automatically know what submodules are necessary for each platform; we must use the
[SetupSettingsManager](/api/invocables/edk2_setup/#edk2toolext.invocables.edk2_setup.SetupSettingsManager)
to provide that information.

!!! Note
    The command specific [Settings Manager](/features/settings_manager) may not provide *ALL* platform data
    required by the command; it only provides the platform data specific to that command. You still need to override some
    methods from
    [Edk2InvocableSettingsInterface](/api/edk2_invocable/#edk2toolext.edk2_invocable.Edk2InvocableSettingsInterface)
    and [MultiPkgAwareSettingsInterface](/api/invocables/edk2_multipkg_aware_invocable/#edk2toolext.invocables.edk2_multipkg_aware_invocable.MultiPkgAwareSettingsInterface)
    that multiple (or all) commands use, which is why they are in the parent class. Don't worry though! If you miss
    overriding a required method, you'll raise a `NotImplementedError`!

**Review the `stuart_setup` specific settings manager [here](/api/invocables/edk2_setup/#edk2toolext.invocables.edk2_setup.SetupSettingsManager).**

## Stuart Update

Next up is `stuart_update`, which is responsible for updating any external dependencies in the workspace. This includes
downloading and performing miscellaneous tasks for external dependencies. You can find details on how external
dependencies work and how to utilize them in the [ext_dep](/features/extdep) section.

As you'll see in the API reference for `UpdateSettingsManager`, no additional methods need to be overwritten. At first
glance, it may seem like `stuart_update` does not need any platform specific information, but it actually does. The key
takeaway is that you'll still need to inherit from `UpdateSettingsManager`; it's just that the necessary platform data
for this command comes from overriding methods in the parent class
[Edk2InvocableSettingsInterface](/api/edk2_invocable/#edk2toolext.edk2_invocable.Edk2InvocableSettingsInterface)
and/or [MultiPkgAwareSettingsInterface](/api/invocables/edk2_multipkg_aware_invocable/#edk2toolext.invocables.edk2_multipkg_aware_invocable.MultiPkgAwareSettingsInterface).

**Review the `stuart_update` specific settings manager [here](/api/invocables/edk2_update/#edk2toolext.invocables.edk2_update.UpdateSettingsManager).**

## Stuart Build

Lastly is the `stuart_build` command, which actually has two phases to it. The first phase is executed via the
`stuart_build` command and uses the `BuildSettingsManager` to setup the environment in preparation for the build. It
will then invoke the `UefiBuilder`, signaling the start of the second phase which consists of most of the customization
afforded to you by EDK2 Pytools.

**Review the `stuart_build` specific settings manager [here](/api/invocables/edk2_ci_build/#edk2toolext.invocables.edk2_ci_build.CiBuildSettingsManager).**

## UefiBuilder

So what has all of these commands been culminating to? They've all been working to prepare a
[Self Describing Environment](/features/sde) for the `UefiBuilder` to operate in. The purpose of the
`UefiBuilder` is to allow the platform to perform various tasks using this environment. Custom made
[UefiBuildPlugins](/features/plugin_manager/#types-of-plugins) will automatically be run Pre and Post build for
all platforms while [UefiHelperPlugins](/features/plugin_manager/#types-of-plugins) will be available to the
developer to help create Platform specific Pre and Post build functionality. The `UefiBuilder` class has a lot to it, so
let's take a look at each part.

### Command Line options

`UefiBuilder` has multiple built in command line options that control the flow of the build. The below code snippet
shows these command line variables and are accessible via `self.<dest>`. Developers can use this to help control flow in
any of the overrideable methods described in the following sections, however they are also used to control build flow
outside the control of the developer.

:::edk2toolext.environment.uefi_build.UefiBuilder.AddPlatformCommandLineOptions
    handler: python
    options:
        heading_level: 4
        show_signature: True
        show_root_full_path: false

While we don't provide you the ability to override this function (without being hacky like overriding it anyway and
calling the superclass in your override), there is an easy way to add CLI options to your build, which is through
Platform Environment Variables

### Platform Environment Variables

Platform environment variables are a powerful tool used throughout the build process. Not only do environment variables
allow you to control build flow within the `UefiBuilder`, but they also are used by the platform fdf and dsc. You can
set platform environment variables in the platform DSC, FDF, Settings File, and Command Line; any variable set in one is
available in the others! A simple example of this would be to add or remove features based off some criteria. With
Edk2-Pytools this is as simple as setting a single env variable during build. We will walk through this example soon.

#### Setting / Getting Environment Variables

It's easy set and get environment variables in the FDF, DSC, Settings file, and Command line as seen in the table below:

| **Type**      | **Set**                  | **Get**                         |
|---------------|--------------------------|---------------------------------|
| Command Line  | VAR [= Value]            | N/A                             |
| FDF/DSC       | DEFINE VAR = Value       | $(VAR)                          |
| Settings File | env.SetValue(Var, Value) | env.GetValue(Var, DefaultValue) |

To support parity with Edk2's build command line option -D/--define, variables passed via the command line are not
required to have a value associated with them. Variables defined this way are considered non-valued variable defines
and should be checked for existence rather then value (i.e. `if env.GetValue(var):` or `if not env.GetValue(var)`).

While you can set and get variables anywhere in the `UefiBuilder` portion of the settings file, we provide the following
three methods to set environment variables, ensuring they are available everywhere that you are allowed to customize:

- [SetPlatformEnv](/api/environment/uefi_build/#edk2toolext.environment.uefi_build.UefiBuilder.SetPlatformEnv)

- [SetPlatfromEnvAfterTarget](/api/environment/uefi_build/#edk2toolext.environment.uefi_build.UefiBuilder.SetPlatformEnvAfterTarget)

- [SetPlatformDefaultEnv](/api/environment/uefi_build/#edk2toolext.environment.uefi_build.UefiBuilder.SetPlatformDefaultEnv)

!!! Warning
    `SetPlatformDefaultEnv` is not like the others. Rather then setting the environment variables directly, it should
    return a limited list of the most commonly overridden variables and their default values! The values returned are
    printed to the terminal when using the `-h, --help` flags so that develops can easily find the common ways to
    customize a platforms build. Additionally, if these variables have not been set anywhere else in the build, they
    will be set to the default values.

!!! Note
    Not all variables are passed through stuart to the actual build command. Only variables with the prefix `BLD_*_`,
    `BLD_DEBUG_` and `BLD_RELEASE_` are considered build values and consumed by the build command.

#### Example

As mentioned above, lets walk through a simple example of build customization with Edk2-Pytools. In this scenario, we
want a simple way to build our platform in three distinct ways. To keep it simple, all we want to customize is the
target type (DEBUG/RELEASE) and the inclusion of the EdkShell. These builds will be DEV, SELFHOST, and RELEASE. From the
command line, we we would call `stuart_build -c Platform.py PROFILE=DEV`. All that needs to be done is to check the
value of profile during `SetPlatformEnv()` and make our build customizations from there.

``` python

def __init__(self):
    self.profiles = {
        "DEV" : {"TARGET" : "DEBUG", "EDK_SHELL": ""},
        "SELFHOST" : {"TARGET" : "RELEASE", "EDK_SHELL": ""},
        "RELEASE" : {"TARGET" : "RELEASE"}
    }
...

def SetPlatformEnv(self):
    build_profile = self.env.GetValue("PROFILE", "DEV") # Default DEV
    if build_profile in self.profiles:
        for key, value in self.profile[build_profile].items():
            self.env.SetValue(key, value, "PROFILE VALUE")
...
```

The environment variables are set, whats next? The target is automatically picked up by the build system, so all that
needs to be done is to add the logic of including the Edk shell or not. This can be done in the platform fdf as seen below:

``` shell
!if $(EDK_SHELL)
FILE APPLICATION = PCD(gPcBdsPkgTokenSpaceGuid.PcdShellFile) {
  SECTION PE32 = <SomePath>/Shell.efi
  SECTION UI = "EdkShell"
}
!endif
```

### Pre / Post Build Customization

Edk2 Pytools offer developers multiple ways to customize the build experience, both Pre and Post Build. The first way is
through [UefiBuildPlugins](/features/plugin_manager/#types-of-plugins) (executed automatically for all platforms)
which is discussed in [Create a Plugin](/features/creating_plugins) section, and through three methods to override in
the `UefiBuilder` (specific to the platform) which will be the focus here.

- [PlatformPreBuild](/api/environment/uefi_build/#edk2toolext.environment.uefi_build.UefiBuilder.PlatformPreBuild)
- [PlatformPostBuild](/api/environment/uefi_build/#edk2toolext.environment.uefi_build.UefiBuilder.PlatformPostBuild)
- [PlatformFlashImage](/api/environment/uefi_build/#edk2toolext.environment.uefi_build.UefiBuilder.PlatformFlashImage)

All three of the callbacks that you can override have access to the same environment, but each happens at a different
time in the build process as outlined below. You can choose to perform specific tasks both prebuild and postbuild such
as moving files around pre build or patching in binary data post build. We also offer a callback for flashing your image
to the device, if you have the infrastructure to do so via command line. You'll have to fully implement it yourself, but
it can greatly speed up the time it takes to get your firmware on your platform.

1. `PlatformPreBuild()`
2. `UefiBuildPlugins` that implement `do_pre_build()`
3. `Build()`
4. `PlatformPostBuild()`
5. `UefiBuildPlugins` that implement `do_post_build()`
6. `PlatformFlashImage()`

Lets end this section by mentioning some of the important things (but not everything) you have access to during the
callbacks mentioned above:

#### Helper Plugins

This is another type of plugin that is talked about in the [Create a Plugin](/features/creating_plugins)
that allows the developers to add in extensions or helper methods to the build
environment that are easy to access. You can easily access them through
`self.Helper.<FunctionName>()`. As an example, if we made that helper called
`YamlToBin(yaml_obj)`, then we could call it via `self.Helper.JsonToBin(yaml)`.

#### The Environment

As we alluded to in one of the previous sections, you'll have access to all of the environment variables set throughout
the DSC, FDF, CLI, and anywhere else in the build. you'll be able to access the environment via `self.env`. To see the
available methods to use, please review the [VarDict](/api/environment/var_dict/#edk2toolext.environment.var_dict.VarDict).

#### Edk2 Pytool Library

The second half of Edk2 Pytools is [Edk2 Pytool Library](https://github.com/tianocore/edk2-pytool-library), which
provides the building blocks of tools that are relevant to UEFI firmware developers. Some of these tools include file
parsers for edk2 specific file types and UEFI defined values and interfaces for usage in python. You can think of Edk2
Pytool Extensions (This) as the simple framework to get your platform building and Edk2 Pytool Library as the building
blocks to do more advanced customization of the build.


text:
# Tests for custom package names

This directory contains test for mockgen generating mocks when imported package
name does not match import path suffix. For example, package with name "client"
is located under import path "github.com/golang/mock/mockgen/internal/tests/custom_package_name/client/v1".

Prior to this patch:

```bash
$ go generate greeter/greeter.go
2018/03/05 22:44:52 Loading input failed: greeter.go:17:11: failed parsing returns: greeter.go:17:14: unknown package "client"
greeter/greeter.go:1: running "mockgen": exit status 1
```

This can be fixed by manually providing `-imports` flag, like `-imports client=github.com/golang/mock/mockgen/internal/tests/custom_package_name/client/v1`.
But, mockgen should be able to automatically resolve package names in such situations.

With this patch applied:

```bash
$ go generate greeter/greeter.go
$ echo $?
0
```

Mockgen runs successfully, produced output is equal to [greeter_mock_test.go](greeter/greeter_mock_test.go) content.

repository: golang/mock

repo_name: golang/mock


text:
# Changelog

This Changelog records major changes between versions.

Not all changes are recorded. Please check git log for details.

## Version 2.2.5

- Add client certificate authentication
- Fixing documentation related to Docker

## Version 2.2.4

- Add options to configure ECS netmask length
- Add an option to disable TLS verification (Note: dangerous)

## Version 2.2.3

- Use the library ipTree to determine whether an IP is global routable, improving the performance
- Google's <IP_ADDRESS> resolver is now marked as "Good ECS" in the example configuration file

## Version 2.2.2

- Allow client to opt-out EDNS0 Client Support
- [JSON-DoH] Honor DNSSEC OK flag for incoming DNS requests
- [JSON-DoH] Add support for non-standard response formats
- `X-Real-IP` is now used in logging if set by frontend load balancer
- Fix documentation

## Version 2.2.1

- Fix messy log

## Version 2.2.0

- Breaking change: The configuration format of doh-server is changed
- Add support for type prefix for upstream addresses of doh-server
- Add support for DNS-over-TLS upstream addresses of doh-server
- Remove `tcp_only` configuration option in doh-server
- Add `no_user_agent` configuration option in doh-server
- Add an RPM package script with SELinux policy
- Fix Opcode never assigned in `jsonDNS.PrepareReply`
- Improve error logging / checking
- Updated Readme

## Version 2.1.2

- Update address for google's resolver
- Fix a typo

## Version 2.1.1

- Add a set of Dockerfile contributed by the community
- Include DNS.SB's resolver in example configuration

## Version 2.1.0

- Add `local_addr` configuration for doh-server (#39)
- Fix a problem when compiling on macOS 10.14.4 or newer
- Add Quad9 DoH server to the example `doh-client.conf`
- Use TCP when appropriate for the given query type/response (AXFR/IXFR)

## Version 2.0.1

- Fix a crash with the random load balancing algorithm.

## Version 2.0.0

**This is a breaking change!** Please update the configuration file after upgrading.

- Implemented two upstream server selector algorithms: `weighted_round_robin` and `lvs_weighted_round_robin`.
- Add a configuration option for doh-server: `log_guessed_client_ip`.

## Version 1.4.2

- Add PID file feature for systems which lacks a cgroup-based process tracker.
- Remove dns.ErrTruncated according to <https://github.com/miekg/dns/pull/815>.

## Version 1.4.1

- Add a configuration option: `debug_http_headers` (e.g. Add `CF-Ray` to diagnose Cloudflare's resolver)
- Add a configuration option: `passrthrough`
- macOS logger is rebuilt with static libswiftCore
- Fix HTTP stream leaking problem, which may cause massive half-open connections if HTTP/1 is in use
- Utilize Go's cancelable context to detect timeouts more reliably.
- Fix interoperation problems with gDNS
- CORS is enabled by default in doh-server
- Documentation updates

## Version 1.3.10

- Enable application/dns-message (draft-13) by default, since Google has finally supported it

## Version 1.3.9

- Fix client crash with `no_cookies = true`
- Add 5380 as an additional default doh-client port
- If `$GOROOT` is defined, Makefile now respects the value for the convenience of Debian/Ubuntu users
- Change the ECS prefix length from /48 to /56 for IPv6, per RFC 7871

## Version 1.3.8

- Workaround a bug causing Firefox 61-62 to reject responses with Content-Type = application/dns-message
- Workaround a bug causing DNSCrypt-Proxy to expect a response with TransactionID = 0xcafe
- TransactionID is now preserved to maintain compatibility with some clients
- Turn on `no_cookies` by default according to the IETF draft
- Update Documentation

## Version 1.3.7

- Add CloudFlare DNS resolver for Tor to the preset
- It is now able to print upstream information if error happens
- Updated default configuration files are now installed to `*.conf.example`
- Workaround a bug causing Unbound to refuse returning anything about the root
- Workaround a bug causing DNSCrypt-Proxy to expect a response with TransactionID = 0xcafe

## Version 1.3.6

- We have a logger for macOS platform now, so logs can be sent to Console.app
- Add an option to disable IPv6, this option is available to client only

## Version 1.3.5

- Limit the frequency of creating HTTP client on bad network condition

## Version 1.3.4

- doh-client now silently fails in case of network error to prevent caching of SERVFAIL
- EDNS0 is now inserted to the beginning of OPT section, to ensure DNSSEC signatures are at the end
- Improve building system
- Update documents

## Version 1.3.3

- Take User-Agent out of common library, that would be better for packaging

## Version 1.3.2

- Fix version string in HTTP User-Agent

## Version 1.3.1

- Fix the "address already in use" issue

## Version 1.3.0

- Breaking change: Add client / server support for multiple listen address
  The `listen` option in the configuration file is a list now

## Version 1.2.1

- Update protocol to IETF draft-07
- Update installation documentations for Ubuntu / Debian

## Version 1.2.0

- Add installation documentations for Ubuntu / Debian
- Include CloudFlare DOH server (<IP_ADDRESS>, <IP_ADDRESS>) in default configuration
- Fix a problem causing `go get` to fail due to relative paths
- Add documentation about `/etc/hosts` preloading

## Version 1.1.4

- Add `no_cookies` option
- Add documentation on privacy issues
- Adapt for CloudFlare DNS service
- Fix a problem causing a single network failure blocking future requests
- Add experimental macOS support

## Version 1.1.3

- Unsupported Content-Type now generates HTTP error code 415

## Version 1.1.2

- Adapt to IETF protocol
- Optimize for HTTP caches

## Version 1.1.1

- Adapt to IETF protocol
- Optimize for HTTP caches
- Add documentation for uninstallation instructions
- Fix build issues

## Version 1.1.0

- Adpat to IETF protocol
- Fix issues regarding to HTTP caching
- Require Go 1.9 to build now
- Fix systemd issue

## Version 1.0.1

- Fix build issues

## Version 1.0.0

- First release
- Relicense as MIT license

repository: satishweb/dns-over-https

repo_name: satishweb/dns-over-https


text:
## :first [**Back**](./../pseudoClass.md)

- `:first` is a CSS pseudo-class selector used to select the first page of a printed document.
- It is used in conjunction with the `@page` rule which selects all pages in a printed document. So, when used with `@page`, `:first` acts kind of like a filter used to select only the first page among all pages.

```css
@page :first {
    /** styles for the first page */
}
```

#### Case: distinguished first page

```css
/* All margins set to 2cm */
@page {
    margin: 2cm;
}

/* Top margin on first page 10cm */
@page :first {
    margin-top: 10cm;
}
```

#### Note

- In addition to `:first`, a `@page` can be used in conjunction with two other pseudo-classes, namely `:left` and `:right`, which select the left and right pages in double-sided documents, respectively.
- Styles specified in a `:first` `@page` rule override any styles specified in `:left` and `:right` `@page` rules.
- According to rules `@page`, you can only change some CSS properties:

categories|items
----------|-----
**Margin Properties**|`margin-top`, `margin-left`, `margin-right`, and `margin-bottom`
**Page Break Properties**|`page-break-after`, `page-break-before`, and `page-break-inside`
**Other Properties**|`orphans` and `windows`

- All pages are automatically classified by user agents into either the `:left` or `:right` pseudo-class. Whether the first page of a document is `:left` or `:right` depends on the major writing direction of the root element. For example, the first page of a document with a **left-to-right** major writing direction would be a `:right` page, and the first page of a document with a **right-to-left** major writing direction would be a `:left` page.
- If a forced break occurs before the first generated box, it is undefined in CSS 2.1 whether `:first` applies to the blank page before the break or to the page after it.

repository: ackuser/css

repo_name: ackuser/css


text:
# react-native-app
 recently,The technology of react-native is very hot,so, I wrote an app for myself, a react-native。

 Pack of the generated apk installation package in the Advanced project (integrated redux state management) [Advanced](https://github.com/cryingbat/react-redux-demo),
 and The installation package of android4.4/5.1/6.0 runs smoothly.
 so I hope you can give me more advice.Thank you.

  The technology stack is involved in the project:[react](https://github.com/facebook/react)+[react-native](https://github.com/facebook/react-native)+[nativebase](https://github.com/GeekyAnts/NativeBase)+[react-navigation](https://github.com/react-navigation/react-navigation)，

  Third-party components:[native-echarts](https://github.com/somonus/react-native-echarts)+[react-native-actionsheet](https://github.com/beefe/react-native-actionsheet)+[react-native-modal](https://github.com/react-native-community/react-native-modal)+[react-native-swiper](https://github.com/leecade/react-native-swiper)+[react-native-vector-icons](https://github.com/oblador/react-native-vector-icons)

## section screenshorts

first:The app will have a full screen rotation of three images，

![](https://github.com/cryingbat/react-native-app/raw/master/screenshorts/4.jpg)
![](https://github.com/cryingbat/react-native-app/raw/master/screenshorts/5.jpg)
![](https://github.com/cryingbat/react-native-app/raw/master/screenshorts/3.jpg)
![](https://github.com/cryingbat/react-native-app/raw/master/screenshorts/2.jpg)
![](https://github.com/cryingbat/react-native-app/raw/master/screenshorts/0.jpg)

 Click on the login store session to enter the home page

 The homepage has three main sections: front page + news + mine

 The list of news items I put on the front page supports loading more and drop-down refresh functions.

Click on the news to enter the news page.。

 The news page has a sliding TAB that supports multi-tab horizontal scrolling. The details are not in place.

 My page is a collection of UI components.

# For beginners, get a quick command of the react-native usage and navigation switch. It has a very big effect. I hope you can study together and make progress together.


text:
# Contributing

Jump in the pit and add something new!

## Adding a Mode

By adding a new mode, you will be creating a new file which exports a function that manipulates data extracted from a source image's bitmap. That may sound like a lot, but it'll essentially come down to basic iteration over a buffer. Starter code has been provided [here](https://github.com/mster/datamosh/blob/master/lib/modes/template).

### Experimenting

Your mosh mode doesn't have to do anything specific -- if you think it's cool, we probably will too. Use your imagination and feel free to experiment!

Most of Datamosh's current modes overwrite existing Red/Green/Blue (RGB) pixel values with something random. If you get stuck or just need some inspiration, check out these examples.

- [Vana mode](https://github.com/mster/datamosh/blob/master/lib/modes/vana.js)
- [Schifty mode](https://github.com/mster/datamosh/blob/master/lib/modes/schifty.js)
- [Before and after images](https://github.com/mster/datamosh#example-images)

Once you have a stub function and some cool name for it, you'll want to import it into Datamosh.

To import your mode, you have two options:

1. Import it into Datamosh by adding an entry in `mosh.MODES`, [here](https://github.com/mster/datamosh/blob/master/lib/mosh.js#L99). (Preferred)
2. Add it to the function property after you initialize Datamosh. Example code on how to do this can be found [here](https://github.com/mster/datamosh/releases/tag/v1.1.0).

### Getting Started

1. Fork datamosh and run `npm install` within the directory.
2. On your fork, create a new branch named `username/work-description`, where `username` is your GitHub username and `work-description` is a short description for your contribution.

   For example: `mster/new-mode`

3. Commit your work to the branch you created.
4. When you're ready for review or to submit your contribution, double check a few things.

- ✓ First, make sure your fork is up to date. If your fork is out of date, you will need to rebase.

- ✓ Next, assure that your code pases `npm test`.

5. If your contribution is more than a single commit, squash all commits into one.
6. Open a pull request to `mster:master`.

## Other Features

Have an feature in mind? Go for it -- if we like it, we will add it.

Follow the [Getting Started](#getting-started) guide if you're new to this.

## Code Style

Datamosh uses [Prettier](https://prettier.io/). To have your contributions accepted, they must also be in StandardJS style.

To test if your code passes, run the test command:
`npm run lint`

## Testing

As of v1.0.0, tests consist of:

- linting using Prettier

## Need Help

We're happy to help out, no matter how small. Open an issue, ping the author (@mster), or join the Discord.

Datamosh has a dedicated Discord server. Feel free to join: https://discord.gg/DhYTmMD

repository: MichaelPaulukonis/datamosh

repo_name: MichaelPaulukonis/datamosh


text:
[![Build Status](https://img.shields.io/travis/vincentriemer/animar/master.svg?style=flat)](https://travis-ci.org/vincentriemer/animar) [![npm version](https://badge.fury.io/js/animar.svg)](https://badge.fury.io/js/animar)

[![bitHound Dependencies](https://www.bithound.io/github/vincentriemer/animar/badges/dependencies.svg)](https://www.bithound.io/github/vincentriemer/animar/master/dependencies/npm) [![bitHound Dev Dependencies](https://www.bithound.io/github/vincentriemer/animar/badges/devDependencies.svg)](https://www.bithound.io/github/vincentriemer/animar/master/dependencies/npm)

[![bitHound Overall Score](https://www.bithound.io/github/vincentriemer/animar/badges/score.svg)](https://www.bithound.io/github/vincentriemer/animar) [![codecov.io](https://codecov.io/github/vincentriemer/animar/coverage.svg?branch=master)](https://codecov.io/github/vincentriemer/animar?branch=master)

[![Sauce Test Status](https://saucelabs.com/browser-matrix/vincentriemer.svg)](https://saucelabs.com/u/vincentriemer)

# Animar

**NOTE**: This is still very much a work in progress (espcially in the documentation department). If you attempt to use this in its current state, you are doing so at your own risk.

## Example

```javascript
var Animar = require('animar');

// Custom easing function (Animar only defaults to a linear ease)
function quadInOut(t, b, c, d) {
  t /= d / 2;
  if (t < 1) { return c / 2 * t * t + b; }
  t--;
  return -c / 2 * (t * (t - 2) - 1) + b;
}

// Initialize the library (set the default easing function to the one created above)
var animar = new Animar({
  defaults: {
    easingFunction: quadInOut
  }
});

// Get the target from the DOM
var target = document.getElementById('target');

// Construct an animation chain and start it immediately.
animar.add(target, { translateX: [0, 300], translateY: [0, 300] })
      .then() // Any animation added after this point will start after the previous ones have finished
      .add(target, { translateX: [300, 0], translateY: [300, 0], { delay: -30 }) // set a negative delay to make it begin sooner than the time the previous step ends.
      .start();
```

repository: vincentriemer/animar

repo_name: vincentriemer/animar


text:
# SFD-MobileNet Train Instructions:

SFD with mobileNet is prepared depending on thid repo: https://github.com/chuanqi305/MobileNet-SSD

Many modifications are done to adapt the model to SFD, specially the layers used for detection and the data augmentation part.

TODO: Add all details of the changes in MobileNet model and add the python scripts used with some instructions.

Doubts about the changes done to the model:
1. They use mean values = 127.5 for the 3 channels, however I used the mean values of ImageNet as done with VGG.

2. Using the early layer with size 160x160 may not be good choice, as the feature map in this very early stage is different than VGG model.

Notes:
1. The training is much slower than SFD-VGG!

TODO: investigate more about this training speed difference.

The training loss and validation accuracy of training process is as follows:

![Alt text](assets/SFD-MobileNet_3CH_validation_accuracy.png)
![Alt text](assets/SFD-MobileNet_3CH_training_loss.png)

repository: bonseyes/SFD

repo_name: bonseyes/SFD


text:
# HW 4: Testing and linting

This homework involves revisions to the files you created in HW 3.

1. (2 points) Change test_create_dataframe.py to be runnable as a test file (using pytest if you prefer).

1. (5 points) Make create_dataframe and test_create_dataframe PEP8 compliant.


text:
# Homepage for Gundla Gårdscafé

![Image description](homepage.png)

This is a website made for Gundla Gårdscafé that is build with Next.js and connected to Sanity as headless CMS.

## Sanity
![Image description](admin.png)

## Installation
- Clone the repository
```
$ git clone https://github.com/juljulia/gundlagardscafe
```
- In the web directory, run:
```
$ npm run dev
```
- Open http://localhost:3000 to view the webpage in the browser.

## Authors
- **Julia Karlsson** - *Initial work* - [Julia](https://Juljulia.github.io)
- **Maja Alin** - *Initial work* - [Maja](https://majaalin.github.io)

## License
This project is licensed under the MIT License.

repository: Juljulia/gundlagardscafe

repo_name: Juljulia/gundlagardscafe


text:
##Package Control Badges

This is a Flask app that allows you to add badges to your Sublime Text Plugins showing your Plugin Downloads. This is very easy to use using the API and the API is hosted on Heroku.

###Demo

The source for the above is:

```html
<a href="https://packagecontrol.io/packages/Terminal"><img src="https://packagecontrol.herokuapp.com/downloads/Terminal.svg"></a>
```

###API Endpoints

The base API endpoints are (currently only for downloads):

```
https://packagecontrol.herokuapp.com/downloads/[Package name].[format]
```

The package name needs to be quoted, like `Theme - Soda` becomes `Theme%20-%20Soda`

Formats currently supported are:

- PNG
- SVG
- JPEG
- GIF
- TIFF

####Colors

You can also change the color of the badge by adding a `color` parameter. The value of this URL parameter is valid CSS hexadecimal color or a normal color name like `17024F` (without the #) or `red`

Example:

Source:

```html
<a href="https://packagecontrol.io/packages/HTML%20Minifier"><img src="https://packagecontrol.herokuapp.com/downloads/HTML%20Minifier.svg?color=EF9F9F"></a>
```

####Styles

There are 3 main styles available to choose from (as given in shields.io):

1. Flat (default)
2. Plastic (legacy)
3. Flat-Square

You can change the styles by adding a `style` parameter after the URL.

Example:

Source:

```html
<a href="https://packagecontrol.io/packages/HTML%20Minifier"><img src="https://packagecontrol.herokuapp.com/downloads/HTML%20Minifier.svg?color=red&style=flat-square"></a>
```

The value of the `style` paramter will be either `plastic`, `flat` or `flat-square`

###To-Do

1. Add more features (that is, endpoints)
2. Add alternate hosting (on OpenShift) to compensate Heroku Free tier limits

###About

Created By Pradipta (geekpradd). Copyright 2015. MIT Licensed.

repository: geekpradd/Package-Control-Badges

repo_name: geekpradd/Package-Control-Badges


text:
# Spotguide for Sprint Boot with MySQL database

This repository was created by Banzai Cloud Pipeline. Spotguides provide automated configuration, logging, monitoring, security, and scaling for your application stacks.

<!-- TOC -->

- [Spotguide for Sprint Boot with MySQL database](#spotguide-for-spring-boot-with-mysql-database)
  - [Development](#development)
    - [Local development](#local-development)
      - [Deploy to a local Kubernetes cluster](#deploy-to-a-local-kubernetes-cluster)
      - [Run tests](#run-tests)
      - [Start application in development mode](#start-application-in-development-mode)
    - [Kubernetes ready Spring Boot](#kubernetes-ready-spring-boot)
  - [Environment variables](#environment-variables)
  - [Endpoints](#endpoints)
    - [`GET /actuator/health/kubernetes`](#get-actuatorhealthkubernetes)
    - [`GET /actuator/prometheus`](#get-actuatorprometheus)
    - [`GET /actuator/health`](#get-actuatorhealth)
    - [`GET /ready`](#get-ready)
    - [`GET /api/v1/users`](#get-apiv1users)
    - [`POST /api/v1/users`](#post-apiv1users)
    - [`GET /api/v1/users/:id`](#get-apiv1usersid)
    - [`PUT /api/v1/users/:id`](#put-apiv1usersid)
    - [`DELETE /api/v1/users/:id`](#delete-apiv1usersid)

<!-- /TOC -->

## Development

Every time you make changes to the source code and update the `master` branch, the CI/CD pipeline will be triggered to test, validate and update the deployment of your application. Check the [`.pipeline.yaml`](.banzaicloud/pipeline.yaml) file for CI/CD steps.

### Local development

#### Deploy to a local Kubernetes cluster

_Requirements:_

- [Docker](https://www.docker.com/)
- [Docker for Desktop](https://www.docker.com/products/docker-desktop)
- [skaffold](https://github.com/GoogleContainerTools/skaffold) and its dependencies

A local Kubernetes cluster must be running (eg. [Docker for Desktop](https://www.docker.com/products/docker-desktop)).

```sh
# verify the Kubernetes context
$ kubectl config get-contexts
# expected output
CURRENT   NAME                 CLUSTER                      AUTHINFO             NAMESPACE
*         docker-for-desktop   docker-for-desktop-cluster   docker-for-desktop
# build the Docker image and deploy via helm
$ cd .banzaicloud
$ skaffold run
```

This will build the application and install all the components to Kubernetes.

#### Run tests

##### Using installed Maven:

_Requirements:_

- [Maven](https://maven.apache.org/)

_Commands:_

```sh
mvn clean package
```

##### Using Docker:

_Requirements:_

- [Docker](https://www.docker.com/)

_Commands:_

```sh
DOCKER_REPO=spotguide-spring-boot DOCKER_TAG=latest mvn compile jib:dockerBuild
```

#### Start application in development mode

This spotguide uses [spring-boot-devtools](https://docs.spring.io/spring-boot/docs/current/reference/html/using-boot-devtools.html), it is a utility dependency that will monitor for any changes in your classpath and automatically restart your server.

Using local Spring Boot and with the SQL compatible H2 database:

_Requirements:_

- [Maven](https://maven.apache.org/)

_Commands:_

```sh
mvn spring-boot:run
```

Using Docker and Docker Compose:

_Requirements:_

- [Docker](https://www.docker.com/)

_Commands:_

```sh
# start dependencies
docker-compose up -d
# build image
DOCKER_REPO=spotguide-spring-boot DOCKER_TAG=latest mvn compile jib:dockerBuild
# start application in development mode
mvn spring-boot:run
```

### Kubernetes ready Spring Boot

Our [`Spring Boot Actuator` library](https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#production-ready) and [Spring Cloud Kubernetes](https://github.com/spring-cloud/spring-cloud-kubernetes) together provides all the essential features to prepare your Spring Boot application truly ready for production on Kubernetes, such as:

- graceful error handling & shutdown
- structured JSON logging
- various HTTP middleware
- health checks
- metrics

## Environment variables

| name                         | description                                                                                | default     |
| ---------------------------- | ----------------------------------------------------------------------------------------------------------------------------- | ----------- |
| `SERVER_PORT`                | Application port                                                                                | 8080        |
| `SPRING_DATASOURCE_URL`      | JDBC URL, scheme: `jdbc:driver:host1[:port1][,host2[:port2],...[,hostN[:portN]]][/[database][?options]]`                      |             |
| `SPRING_DATASOURCE_USERNAME` | Database user                                                                                |             |
| `SPRING_DATASOURCE_PASSWORD` | Database user password                                                                                |             |
| `SPRING_DATASOURCE_DATABASE` | Database database name                                                                                |             |

## Endpoints

These are the available REST endpoints in the sample application:

### `GET /actuator/health/kubernetes`

Kubernetes endpoint, returns basic [Pod](https://kubernetes.io/docs/concepts/workloads/pods/pod/) information, like name, namespace and image.

### `GET /actuator/prometheus`

[Prometheus](https://prometheus.io) metrics endpoint.

### `GET /actuator/health`

Health check, liveness probe endpoint. Returns `200` when the application is healthy, can reach the database.

### `GET /api/v1/users`

Fetch all users.

### `POST /api/v1/users`

Create a new user. The request body has the following schema:

```json
{
  "email": "",
  "userName": "",
  "firstName": "",
  "lastName": ""
}
```

### `GET /api/v1/users/:id`

Fetch a user.

### `PUT /api/v1/users/:id`

Update a user. The request body has the same schema as [`POST /api/v1/users`](#post-apiv1users).

### `DELETE /api/v1/users/:id`

Delete a user.

## Optional Kafka endpoints

You have to enable Kafka support via running it with `SPRING_KAFKA_ENABLED=true`.

### `GET /api/v1/kafka`

Fetch all Kafka messages.

### `POST /api/v1/kafka`

Send a new message to the `"spring-boot"` Kafka topic.

```json
{
  "message": "hello-spring-boot"
}
```

## Build Run and Test locally

```bash
## Build and Test locally with Docker for Mac Kubernetes
DOCKER_REPO=banzaicloud/spotguide-spring-boot DOCKER_TAG=latest mvn compile jib:dockerBuild
helm dep update .banzaicloud/charts/spotguide-spring-boot
helm upgrade --install spotguide-spring-boot .banzaicloud/charts/spotguide-spring-boot --set ingress.enabled=true --set "ingress.hosts[0]=localhost" --set monitor.enabled=true --set pipeline-ingress.enabled=true

# Check the application (if Ingress not enabled)
kubectl port-forward deployment/spotguide-spring-boot 8080

# Access the Spring application
open http://localhost:[8080]
```

```bash
# Delete the Helm release
helm delete --purge spotguide-spring-boot
```

```bash
# Build the fat JAR
mvn clean package -DskipTests

SPRING_DATASOURCE_USERNAME=sparky SPRING_DATASOURCE_PASSWORD=sparky123 java -jar target/app.jar

curl -H "Content-Type: application/json" http://localhost:8080/api/v1/users -d<EMAIL_ADDRESS>```

repository: spotguides/spring-boot

gha_language: Java

repo_name: spotguides/spring-boot


text:
# **buildcannon**

## This is an automation build tool for iOS (for now).

It currently supports the commands bellow:
- [x] `buildcannon self-update`
    - Starts a self updating process that will update the buildcannon binary.

- [x] `buildcannon create`
    - Generates a project file at [project path]/buildcannon/default.cannon.

- [x] `buildcannon list`
    - List available targets to distribute or export.

- [x] `buildcannon create-target`
    - Generates a project file at [project path]/buildcannon/target name.cannon, "target name" is specified in the following questions process.

- [x] `buildcannon distribute [--all] [--targets=["target name,other target name"]] [--legacy-build]<EMAIL_ADDRESS>--password=******]`
    - Uses the information in the default.cannon file to distribute your app to TestFlight.
    - When provided a **target name** the information in the `target name.cannon` file to distribute your app to TestFlight with the configurations from `default.cannon` overrided by the configurations in the target file.
    - When a list of targets is provided, it will distribute each target.
    - When `--all` is provided the process will distribute each target in the buildcannon folder.
    - When `--legacy-build` is provided the process of archive will use the legacy build system, compatible with Xcode 9 and previous.

- [ ] `buildcannon archive [--targets=["target name,other target name"]] --output="/path/to/save/archive"`
    - Starts the archive process and moves the output to the specified path.

- [x] `buildcannon export [--all] [--targets=["target name,other target name"]] --output-path="/path/to/save/output.ipa" --export-method=[app-store | ad-hoc | development | enterprise] [--legacy-build]`
    - Uses the information in the default.cannon file to export your app to a IPA file and saves it to `output-path`.

- [x] `buildcannon upload --ipa-path="/path/to/ipa"<EMAIL_ADDRESS>--password=******]`
    - Uploads the given IPA file to AppStore Connect.

- [x] `buildcannon run-tests --scheme="MyScheme" --platform="iOS|tvOS|macOS" --device="iPhone Xs|Apple TV 4K" --os-version="12.2|11.3|10.14.5"`
    - Run the test suits in the specified scheme, in the specified platform, in the specified device and version.
    - If any test fails, it stops and fails immediatelly.

## **Install**

I'm assuming that you already have `swift toolchain 5.x` installed. You MUST have the swift.org or the Xcode built-in installed.
I'm assuming that you already have Homebrew installed.

Now that we are in the same page, let's begin.

Just copy and paste the following command in the terminal:

`sh -c "$(curl -s https://raw.githubusercontent.com/andersonlucasg3/buildcannon/master/installer/install.sh)"`

If the logs say that everything is ok, just start executing `buildcannon --help`, and be happy.

:D

gha_language: Swift


text:
**NOTE**: Codacy now supports [Golang coverage reports directly](https://docs.codacy.com/coverage-reporter/#submitting-coverage-for-golang). This tool is therefore no longer required to submit coverage reports.

---

# godacov [![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fschrej%2Fgodacov.svg?type=shield)](https://app.fossa.io/projects/git%2Bgithub.com%2Fschrej%2Fgodacov) [![Security Rating](https://sonarcloud.io/api/project_badges/measure?project=schrej_godacov&metric=security_rating)](https://sonarcloud.io/dashboard?id=schrej_godacov)

godacov is a command-line tool to publish test coverage reports generated with `go test -coverprofile=<filename>` to [Codacy](https://codacy.com).

## How to use
Install godacov using `go get`
```
$ go get github.com/schrej/godacov
```

Retrieve a project token from codacy from `Your Project > Settings > Integrations > Project API`.

Run your tests and generate the coverage report.
```

go test -coverprofile=coverage.out
```

Finally publish the results to Codacy using
```

godacov -t <project token> -r ./coverage.out -c <current commit id>
```

### Travis CI
If you are using Travis CI you should add your project token as a secret environment variable, then run the following command in your script. Remember that you have to append `-coverprofile=coverage.out` to your test command.
```
godacov -t $CODACY_TOKEN -r ./coverage.out -c $TRAVIS_COMMIT
```

## CLI Usage

```
Usage:
  godacov [flags]

Flags:
  -i, --allow-insecure    Allow insecure connection to base URL
  -a, --api-base string   The base URL of the codacy API server to use (default "https://api.codacy.com")
  -c, --commit string     The hash of the commit to provide coverage for
  -h, --help              help for godacov
  -r, --report string     coverage report file generated by 'go test'
  -t, --token string      Codacy project token
```

## License
[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fschrej%2Fgodacov.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Fschrej%2Fgodacov?ref=badge_large)

repository: schrej/godacov

repo_name: schrej/godacov


text:
---
layout: default
title: Before Annotation
parent:
    title: Annotations
    url: annotations.html
---

# Before Annotation

Marks an action method that needs to be executed before the main action method.

## Usage

The `Before` annotation can be applied at method level.

## Parameters

- `priority` (optional) - Priority order of method execution, default: *10*

## Examples

```java
 public class SampleAction extends ActionSupport {

  @Before
  public void isAuthorized() throws AuthenticationException {
    // authorize request, throw exception if failed
  }

  public String execute() {
     // perform secure action
     return SUCCESS;
  }
 }
```


text:
---
title: Authenticity
linked_list_url: "https://danielmall.com/articles/authenticity/"
---

When asked for some advice on presenting, Jeremy Keith answered:

  The most important thing is authenticity. Once you can fake that, you've made it.

Via the ShopTalk Show podcast

repository: iChris/chrisennsdotcom

gha_language: Nunjucks

repo_name: iChris/chrisennsdotcom