text:
# [Argonne Amplicon Library Sequencing](https://www.anl.gov/bio/environmental-sample-preparation-and-sequencing-facility) – Preparation and Submission

## General Submission Requirements

#### Sample sheet
*	Must include Unique sample IDs and DNA concentrations
*	Samples are arranged in rows (A1-A12, B1-B12, etc.)
*	Blank wells are kept at the end of plate and not scattered about or in the middle
*	Blank wells should be identified as blank

#### Amplicon library preparation
*	200-700 samples are recommended for a submission
*	20 uL of volume ranging in concentration from 1-50ng/uL
*	Samples are submitted in fully-skirted 96-well plates with aluminum foil plate seals

#### Sample submission
*	Email Sarah Owens<EMAIL_ADDRESS>and Stephanie Greenwald<EMAIL_ADDRESS>with final number of samples along with the primer set to request for a quote
*	Once the paperwork started, email the completed sample sheet to Sarah and Stephanie
*	Samples need to be sent on dry ice and place cardboard or something rigid between the plates to ensure that the plates don’t break or pierce each other
    -  **Note:** Shipping with dry ice is catagorized as hazardous shippping, please refer to [hazardous shipping SOP](https://github.com/germs-lab/SOPs/blob/master/HazardousShipping.md) for proper instruction
*	Shipment should be made on Monday or Tuesday to make sure the samples are delivered during business days
*	Ship to:

Stephanie Greenwald

Argonne National Laboratory

9700 S. Cass Avenue

Bldg. 446, Rm. A175

Lemont, IL 60439

(630) 252-3896

## Sample Inbound into GERMS

#### Requirements
*	[Metadata file](https://github.com/germs-lab/SOPs/blob/master/data_management_SOPs/GERMS_Lab_Data_Management_101.md), uploaded on [CyBox](https://iastate.app.box.com/folder/71875390050)
*	DNA samples (20 uL of volume ranging in concentration from 1-50ng/uL)

#### Submit your samples to GERMS
1.	Contact Adina and JiJY to confirm number of samples
2.	JiJY creates sample sheet for Argonne submission and identify sample location (plate and well numbers)
    - **Note:** Samples are arranged in rows (A1-A12, B1-B12, etc.)
3.	Collaborators fill Sample IDs, DNA concentrations (and associated metadata, if you want them to be included in the mapping file)
4.	Collaborators contact JiJY to communicate about providing samples according to the sample sheet
    - **Note:** Samples could be provided in both individual tubes or fully-skirted 96-well plates, depends on total number of samples

repository: germs-lab/SOPs

path: /DNA sequencing/Argonne.md

gha_language: Roff

repo_name: germs-lab/SOPs


text:
# Overview

This repo is a fork of the code for the
["TensorFlow for poets 2" codelab](https://codelabs.developers.google.com/codelabs/tensorflow-for-poets-2) adapted to perform a binary classification.

The code is adapted to provide a mycological classifier that can be used as an educational tool to provide a binary classification of `Active` and `Not Active` for a given specimen. You can take a guess on what _'active'_ means :).

__Please note that this is highly experimental and should not be used as an authoritative classification tool.__

# Making the project

The android project is in `/android`. Just load it into Android Studio and run. You can use the gradle build file also.

## Training the Classifier

Use the approach from the ["TensorFlow for poets" codelab](https://codelabs.developers.google.com/codelabs/tensorflow-for-poets) to train your classifier.
The images should be put into a structure like so:

    images/
    |-----/Active/...
    |-----/Not Active/...

The current version has been trained on 505 active and 760 not active images with 4000 training cycles. The accuracy is about 80-90%.
Accuracy can be improved by training on a much larger image set, therefore the ongoing effort would be to keep adding images to the set, especially the active set.

Currently, in real use, the classifier will report a significant number of false positives and some false negatives.

# Content

The `scripts` directory contains the original helpers to compact the Tensorflow Classification Model that is generated by the classfier training.
The compacted model and labels are put into the android/assets/ folder.

# Use

Start app, point camera to a specimen, read the probablilities.

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# Android PDF View

Library for displaying PDF documents on Android, inspired by the awsome project [AndroidPdfViewer](https://github.com/barteksc/AndroidPdfViewer). It use [PdfiumAndroid](https://github.com/barteksc/PdfiumAndroid) to decod and render PDF files.

# Why another wheel?

A good reason is I need a more efficient and more configurable PDF rendering library to display PDF documents. There are some advantages of this library:

- Memory reuse and no memory jitter. This library will recycle the bitmaps that no longer visible and reuse it, that avoid memory recycle and reallocate.

- Very efficient. No frames lose any more when scrolling.

- Easy to config and extend.

A picture is worth a thousand words:

![scroll](images/scroll.gif)

*Rendering performance*

![Memory usage](images/memory_usage.png)

*Memory usage*

# Installation

Library is available in jcenter repository, add this script to your build.gradle file to install:

```gradle
compile 'io.ea:pdfview:1.1.0'
```

# ProGuard

Add following rule to your proguard config file:

```
-keep class com.shockwave.**
```

# How to use

First include `PDFView` to your layout:

```xml
<io.ea.documentview.pdf.PDFView
    andorid:id="@+id/pdf"
    android:layout_width="match_parent"
    android:layout_height="match_parent"/>
```

Alternatively, you could use the `WritablePDFView` that allows you to handwrite.

 For more details, please check out the samples of this project.

# License

This project is under the [Apache-2.0](http://www.apache.org/licenses/LICENSE-2.0)

```
Copyright 2018 Nano Michael

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: NanoMichael/AndroidPDFView

repo_name: NanoMichael/AndroidPDFView


text:
# GetXRPRippleAddressDetailsResponseItem

## Properties
Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**balance** | [**GetXRPRippleAddressDetailsResponseItemBalance**](GetXRPRippleAddressDetailsResponseItemBalance.md) |  |
**incoming_transactions_count** | **int** | Defines the count of all confirmed incoming transactions from the address for coins. This applies to coins only, not to tokens transfers |
**outgoing_transactions_count** | **int** | Defines the count of all confirmed outgoing transactions for coins. This applies to coins only, not to tokens transfers |
**sequence** | **int** | Defines the transaction input's sequence as an integer, which is is used when transactions are replaced with newer versions before LockTime. |
**transactions_count** | **int** | Represents the total number of all transactions as part of this block. |

[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

license: MIT

branch_name: refs/heads/main

gha_license_id: NOASSERTION


text:
Arouter
--------
# Install

Some components depend on external libraries, such as

[Boost](www.boost.org)

[LIMBO](https://github.com/limbo018/Limbo) Configure, make and install the LIMBO package. Set environment variable LIMBO\_DIR to the path, or specify the path to the library as Cmake cache variable LIMBO\_DIR `cmake -DLIMBO_DIR=$PATH`

[SparseHash](https://github.com/sparsehash/sparsehash) Configure, make and install the Google Sparse Hash package. Set environment variable SPARSE\_HASH\_DIR to the path, or specify the path to the library as Cmake cache variable SPARSEHASH\_DIR `cmake -DSPARSEHASH_DIR=$PATH`

Build the program:
```
mkdir build
cd build
cmake -DCMAKE_BUILD_TYPE=Release -DBUILD_DOCUMENTATION=ON ..
cmake -DCMAKE_BUILD_TYPE=Release  .. (alternative) # If no doxygen
make
make doc (optional)
```

Specify the install prefix:
```
cmake -DCMAKE_INSTALL_PREFIX=./install
```
```
--------
# Usage
The program options:
```
--designType -b:    Optional. The format of input design. Options: "ispd08" "ispd08pin"
--designFile -f:    The input placement/benchmark
--iopin             Optional. The file specifying the IO ports, which are the ones that need to be labeled for the GDSII
--symnet            Optional. The file specifying which pairs of nets need to be routed symmetrically.
--placementLayout   Optional. The placement GDSII layout. The shapes in this layout will be regarded as obstacles in the routing.
--techLef -l:       The technology LEF file
--techfile -t:      The techfile from PDK. Used to get the correct layer ID.
--grAlgo -g:        Optional. The global routing algorithm to be used. Now only has "SequentialAStar"
--drAlgo -g:        Optional. The detailed routing algorithm to be used. Now only has "SequentailAStar"
--log:              Optional. The output log file name
--out:              Optional. The file name for the output GDSII layout file. Default "out.gds"
```

--------
# Example of running the software

A example of the top-level script is provided in `./flow`

Put the compiled binary in `./flow`, and run
```
source run.sh $PATH_TO_DESIGN
```

In `PATH_TO_DESIGN`, 6 inputs are required:

```
$DESIGN.gds
$DESIGN.gr
$DESIGN.iopin
$DESIGN.sub
$DESIGN.symnet
$DESIGN.wcon
```

where `$DESIGN` is the same as the folder name of the input path.

--------
--------
# Copyright
The software is released under MIT license except third party packages.

Third party package **LEF/DEF v5.8 and Above Toolkit** is released under Apache License. [Web](https://projects.si2.org/openeda.si2.org/projects/lefdefnew/)

Third party package **Limbo** is released under MIT License. [GitHub](https://github.com/limbo018/Limbo)

Third party package **Google Test** is released under BSD-3-Clause License. [GitHub](https://github.com/google/googletest)

Third party package **cmdline** is released under BSD-3-Clause License. [Github](https://github.com/tanakh/cmdline)

Third party package **boost** is released under Boost Software License. [Web](https://www.boost.org/)

Third party package **CMake** is released under BSD 3-Clause License. [Web](https://cmake.org/)

Third parth packagea **Google SparseHash** under BSD 3-Clause License. [GitHub](https://github.com/sparsehash/sparsehash) [SourceForge](http://goog-sparsehash.sourceforge.net/)

repository: rbarzic/MAGICAL

repo_name: rbarzic/MAGICAL


text:
# WebSocket based chat

A **Symfony 4** based application for simple chat functionality.

**Requirements**
1. `PHP 7.1`
2. `MySQL 5.7`
3. `Composer`

**Installation**
1. `git pull`
2. `composer install`
3. `bin/console server:start`
4. `bin/console chat:start`

gha_language: PHP

gha_license_id: MIT


text:
# 1.2 - xxxx-xx-xx

## Changes affecting backwards compatibility

- The Nim compiler now implements a faster way to detect overflows based
  on GCC's `__builtin_sadd_overflow` family of functions. (Clang also
  supports these). Some versions of GCC lack this feature and unfortunately
  we cannot detect this case reliably. So if you get compilation errors like
  "undefined reference to `__builtin_saddll_overflow`" compile your programs
  with `-d:nimEmulateOverflowChecks`.

### Breaking changes in the standard library

- `base64.encode` no longer supports `lineLen` and `newLine`.
  Use `base64.encodeMIME` instead.
- `os.splitPath()` behavior synchronized with `os.splitFile()` to return "/"
   as the dir component of "/root_sub_dir" instead of the empty string.
- `sequtils.zip` now returns a sequence of anonymous tuples i.e. those tuples
  now do not have fields named "a" and "b".
- `strutils.formatFloat` with `precision = 0` has the same behavior in all
  backends, and it is compatible with Python's behavior,
  e.g. `formatFloat(3.14159, precision = 0)` is now `3`, not `3.`.
- Global variable `lc` has been removed from sugar.nim.
- `distinctBase` has been moved from sugar.nim to typetraits and now implemented as
  compiler type trait instead of macro. `distinctBase` in sugar module is now deprecated.
- `CountTable.mget` has been removed from `tables.nim`. It didn't work, and it
  was an oversight to be included in v1.0.
- `tables.merge(CountTable, CountTable): CountTable` has been removed.
  It didn't work well together with the existing inplace version of the same proc
  (`tables.merge(var CountTable, CountTable)`).
  It was an oversight to be included in v1.0.
- `options` now treats `proc` like other pointer types, meaning `nil` proc variables
  are converted to `None`.
- `relativePath("foo", "foo")` is now `"."`, not `""`, as `""` means invalid path
  and shouldn't be conflated with `"."`; use -d:nimOldRelativePathBehavior to
  restore the old behavior
- `joinPath(a,b)` now honors trailing slashes in `b` (or `a` if `b` = "")
- `times.parse` now only uses input to compute its result, and not `now`:
  `parse("2020", "YYYY", utc())` is now `2020-01-01T00:00:00Z` instead of
  `2020-03-02T00:00:00Z` if run on 03-02; it also doesn't crash anymore when
  used on 29th, 30th, 31st of each month.
- `httpcore.==(string, HttpCode)` is now deprecated due to lack of practical
  usage. The `$` operator can be used to obtain the string form of `HttpCode`
  for comparison if desired.
- `os.walkDir` and `os.walkDirRec` now have new flag, `checkDir` (default: false).
  If it is set to true, it will throw if input dir is invalid instead of a noop
  (which is the default behaviour, as it was before this change),
  `os.walkDirRec` only throws if top-level dir is invalid, but ignores errors for
  subdirs, otherwise it would be impossible to resume iteration.

### Breaking changes in the compiler

- Implicit conversions for `const` behave correctly now, meaning that code like
  `const SOMECONST = 0.int; procThatTakesInt32(SOMECONST)` will be illegal now.
  Simply write `const SOMECONST = 0` instead.
- The `{.dynlib.}` pragma is now required for exporting symbols when making
  shared objects on POSIX and macOS, which make it consistent with the behavior
  on Windows.
- The compiler is now more strict about type conversions concerning proc
  types: Type conversions cannot be used to hide `.raise` effects or side
  effects, instead a `cast` must be used. With the flag `--useVersion:1.0` the
  old behaviour is emulated.
- Tuple expressions are now parsed consistently parsed as
  `nnkTupleConstr` node. Will affect macros expect nodes to be of type `nnkPar`.

## Library additions

- `macros.newLit` now works for ref object types.
- `system.writeFile` has been overloaded to also support `openarray[byte]`.
- Added overloaded `strformat.fmt` macro that use specified characters as
  delimiter instead of '{' and '}'.
- introduced new procs in `tables.nim`: `OrderedTable.pop`, `CountTable.del`,
  `CountTable.pop`, `Table.pop`
- To `strtabs.nim`, added `StringTable.clear` overload that reuses the existing mode.
- Added `browsers.osOpen` const alias for the operating system specific *"open"* command.
- Added `sugar.dup` for turning in-place algorithms like `sort` and `shuffle` into
  operations that work on a copy of the data and return the mutated copy. As the existing
  `sorted` does.
- Added `sugar.collect` that does comprehension for seq/set/table collections.
- Added `sugar.capture` for capturing some local loop variables when creating a closure.
  This is an enhanced version of `closureScope`.
- Added `typetraits.tupleLen` to get number of elements of a tuple/type tuple,
  and `typetraits.get` to get the ith element of a type tuple.
- Added `typetraits.genericParams` to return a tuple of generic params from a generic instantiation
- Added `os.normalizePathEnd` for additional path sanitization.
- Added `times.fromUnixFloat,toUnixFloat`, subsecond resolution versions of `fromUnix`,`toUnixFloat`.
- Added `wrapnils` module for chains of field-access and indexing where the LHS can be nil.
  This simplifies code by reducing need for if-else branches around intermediate maybe nil values.
  E.g. `echo ?.n.typ.kind`
- Added `minIndex`, `maxIndex` and `unzip` to the `sequtils` module.
- Added `os.isRelativeTo` to tell whether a path is relative to another
- Added `resetOutputFormatters` to `unittest`
- Added `expectIdent` to the `macros` module.
- Added `os.isValidFilename` that returns `true` if `filename` argument is valid for crossplatform use.

- Added a `with` macro for easy function chaining that's available
  everywhere, there is no need to concern your APIs with returning the first argument
  to enable "chaining", instead use the dedicated macro `with` that
  was designed for it. For example:

```nim

type
  Foo = object
    col, pos: string

proc setColor(f: var Foo; r, g, b: int) = f.col = $(r, g, b)
proc setPosition(f: var Foo; x, y: float) = f.pos = $(x, y)

var f: Foo
with(f, setColor(2, 3, 4), setPosition(0.0, 1.0))
echo f

```

- Added `times.isLeapDay`
- Added a new module, `std / compilesettings` for querying the compiler about
  diverse configuration settings.
- `base64` adds URL-Safe Base64, implements RFC-4648 Section-7.
- Added `net.getPeerCertificates` and `asyncnet.getPeerCertificates` for
  retrieving the verified certificate chain of the peer we are connected to
  through an SSL-wrapped `Socket`/`AsyncSocket`.
- Added `distinctBase` overload for values: `assert 12.MyInt.distinctBase == 12`

## Library changes

- `asyncdispatch.drain` now properly takes into account `selector.hasPendingOperations`
  and only returns once all pending async operations are guaranteed to have completed.
- `asyncdispatch.drain` now consistently uses the passed timeout value for all
  iterations of the event loop, and not just the first iteration.
  This is more consistent with the other asyncdispatch apis, and allows
  `asyncdispatch.drain` to be more efficient.
- `base64.encode` and `base64.decode` was made faster by about 50%.
- `htmlgen` adds [MathML](https://wikipedia.org/wiki/MathML) support
  (ISO 40314).
- `macros.eqIdent` is now invariant to export markers and backtick quotes.
- `htmlgen.html` allows `lang` on the `<html>` tag and common valid attributes.
- `macros.basename` and `basename=` got support for `PragmaExpr`,
  so that an expression like `MyEnum {.pure.}` is handled correctly.
- `httpclient.maxredirects` changed from `int` to `Natural`, because negative values
  serve no purpose whatsoever.
- `httpclient.newHttpClient` and `httpclient.newAsyncHttpClient` added `headers`
  argument to set initial HTTP Headers, instead of a hardcoded empty `newHttpHeader()`.
- `parseutils.parseUntil` has now a different behaviour if the `until` parameter is
  empty. This was required for intuitive behaviour of the strscans module
  (see bug #13605).
- `std/oswalkdir` was buggy, it's now deprecated and reuses `std/os` procs
- `net.newContext` now performs SSL Certificate checking on Linux and OSX.
  Define `nimDisableCertificateValidation` to disable it globally.
- new syntax for lvalue references: `var b {.byaddr.} = expr` enabled by `import pragmas`

## Language additions

- An `align` pragma can now be used for variables and object fields, similar
  to the `alignas` declaration modifier in C/C++.

- `=sink` type bound operator is now optional. Compiler can now use combination
  of `=destroy` and `copyMem` to move objects efficiently.

- `var a {.foo.}: MyType = expr` now lowers to `foo(a, MyType, expr)` for non builtin pragmas,
  enabling things like lvalue references, see `pragmas.byaddr`

## Language changes

- Unsigned integer operators have been fixed to allow promotion of the first operand.
- Conversions to unsigned integers are unchecked at runtime, imitating earlier Nim
  versions. The documentation was improved to acknowledge this special case.
  See https://github.com/nim-lang/RFCs/issues/175 for more details.

### Tool changes

- Fix Nimpretty must not accept negative indentation argument because breaks file.

### Compiler changes

- JS target indent is all spaces, instead of mixed spaces and tabs, for
  generated JavaScript.
- The Nim compiler now supports the ``--asm`` command option for easier
  inspection of the produced assembler code.
- The Nim compiler now supports a new pragma called ``.localPassc`` to
  pass specific compiler options to the C(++) backend for the C(++) file
  that was produced from the current Nim module.
- The compiler now inferes "sink parameters". To disable this for a specific routine,
  annotate it with `.nosinks`. To disable it for a section of code, use
  `{.push sinkInference: off.}`...`{.pop.}`.
- The compiler now supports a new switch `--panics:on` that turns runtime
  errors like `IndexError` or `OverflowError` into fatal errors that **cannot**
  be caught via Nim's `try` statement. `--panics:on` can improve the
  runtime efficiency and code size of your program significantly.
- The compiler now warns about inheriting directly from `system.Exception` as
  this is **very bad** style. You should inherit from `ValueError`, `IOError`,
  `OSError` or from a different specific exception type that inherits from
  `CatchableError` and cannot be confused with a `Defect`.
- The error reporting for Nim's effect system has been improved.

## Bugfixes

- The `FD` variant of `selector.unregister` for `ioselector_epoll` and
  `ioselector_select` now properly handle the `Event.User` select event type.
- `joinPath` path normalization when `/` is the first argument works correctly:
  `assert "/" / "/a" == "/a"`. Fixed the edgecase: `assert "" / "" == ""`.
- `xmltree` now adds indentation consistently to child nodes for any number
  of children nodes.

branch_name: refs/heads/devel


text:
# File manager plugin

[![Build Status](https://travis-ci.org/xianweics/filemanager-plugin.svg?branch=master)](https://travis-ci.org/xianweics/filemanager-plugin)
[![Coverage Status](https://coveralls.io/repos/github/xianweics/filemanager-plugin/badge.svg)](https://coveralls.io/github/xianweics/filemanager-plugin)
[![License](https://img.shields.io/badge/license-MIT-brightgreen.svg)](https://github.com/xianweics/filemanager-plugin/blob/master/LICENSE)

This filemanager plugin allows you to delete, zip/unzip(.zip/.tar/.tar.gz), move, rename, copy files or directories
 before and after builds.

# Install
`npm install filemanager-plugin --save-dev`

# Usage

# Webpack.config.js

```javascript
const FileManagerPlugin = require('filemanager-plugin');

module.exports = {
  plugins: [
    new FileManagerPlugin({
      start: {
        // ...
      },
      end: {
        zip: [
          { source: './src/demo', destination: './dest/demo.zip', type: 'zip', option: { }}
        ],
        del: [
          { source: './src/demo' }
        ],
        unzip: [
          { source: './src/demo.zip', destination: './dest/demo', type: 'zip', option: { }},
        ]
      }
    })
  ]
}
```

## APIs

### webpack.config.js

```javascrip
module.exports = {
  plugins: [new FileManagerPlugin(option)],
};
```

#### Events

- `start`: Adds a hook right before running the compiler.
Refer to webpack [beforeRun](https://webpack.js.org/api/compiler-hooks/#beforeRun) hook.
- `end`: Executed when the compilation has completed.
Refer to webpack [done](https://webpack.js.org/api/compiler-hooks/#done) hook.

The `start` and `end` events will register to compiler hooks in the
right way. In the example below, the start event with `unzip` command will run first,
and then the end event with `zip` after.

```javascript
const FileManagerPlugin = require('filemanager-plugin');
module.exports = {
  plugins: [
    new FileManagerPlugin({
      start: {
        unzip: [
          { source: './src/demo0.zip', destination: './dest/demo0', type: 'zip'}
        ]
      },
      end: {
        zip: [
          { source: './src/demo1', destination: './dest/demo1.zip', type: 'zip', option: { }}
        ]
      }
    })
  ]
}
```

### Commands

|  Name   | Type  |  Description |
|  :---   | :---  |      ---     |
| `zip`    | `{Array}` | Zip files or directories by using `tar`, `tgz`, `gzip` or `zip`. However, `gzip` only supports compress single file. You need to use `tgz` to zip a directory. |
| `unzip`  | `{Array}` | Unzip files or directories. The usage is Same as `zip`. |
| `del`    | `{Array}` | Delete multiple files or directories. |
| `copy`   | `{Array}` | Copy multiple files or directories. |
| `move`   | `{Array}` | Move multiple files or directories. |
| `rename` | `{Array}` | Rename multiple files or directories. |

These commands would be called when each hook which has been registered is called.
Also, each operate will be executed in order base on `Array` order.
In this example below, in the end event, the zip command will run first, and then the delete after:

```javascript
const FileManagerPlugin = require('filemanager-plugin');

module.exports = {
  plugins: [
    new FileManagerPlugin({
      end: {
        zip: [
          { source: './src/demo1', destination: './dest/demo1.zip', type: 'zip', option: { }}
        ],
        del: [
          { source: './src/demo2'}
        ]
      }
    })
  ]
}
```

#### `zip` example

```javascript
module.exports = {
  plugins: [
    new FileManagerPlugin({
      end: {
        zip: [
          { source: './src/demo1', destination: './dest/demo1.zip', type: 'zip', option: { }},
          { source: './src/demo2', destination: './dest/demo2.tar', type: 'tar'},
          { source: './src/demo3', destination: './dest/demo3.tgz', type: 'tgz'},
          { source: './src/demo4.html', destination: './dest/demo4.html.gz', type: 'gzip'},
          { source: './src/demo5.html', destination: './dest/demo5.html.zip', type: 'zip'}
        ]
      }
    })
  ]
}
```
- `source {String}`: Compressed source path which can be a file or directory.
- `destination {String}`: Compressed destination path.
- `type {String}`: Compressed type. Default is `zip`.
- `option {String}`: The same as [opts](https://github.com/node-modules/compressing#compressfile)

#### `unzip` example

```javascript
module.exports = {
  plugins: [
    new FileManagerPlugin({
      end: {
        unzip: [
          { source: './src/demo1.zip', destination: './dest/demo.zip'},
          { source: './src/demo2.tar', destination: './dest/demo.tar', type: 'tar'},
          { source: './src/demo3.tgz', destination: './dest/demo.tgz', type: 'tgz'},
          { source: './src/demo4.html.gz', destination: './dest/demo4.html', type: 'gzip'},
          { source: './src/demo5.html.zip', destination: './dest/demo5.html', type: 'zip'},
        ]
      }
    })
  ]
}
```

- `source {String}`: Uncompressed source path.
- `destination {String}`: Uncompressed destination path.
- `type {String}`: Uncompressed type. Default is `zip`.
- `option {String}`: The same as [opts](https://github.com/node-modules/compressing#compressfile)

#### `del` example

```javascript
module.exports = {
  plugins: [
    new FileManagerPlugin({
      end: {
        del: [
          { source: './src/demo'},
          { source: './src/demo1/index.html'}
        ]
      }
    })
  ]
}
```

- `source {String}`: Deleted path which can be a file or directory.

#### `copy` example

```javascript
module.exports = {
  plugins: [
    new FileManagerPlugin({
      end: {
        copy: [
          { source: './src/demo', destination: './dest/demo'}
        ]
      }
    })
  ]
}
```

- `source {String}`: Copied source path.
- `destination {String}`: Copied destination path.

#### `move` example

```javascript
module.exports = {
  plugins: [
    new FileManagerPlugin({
      end: {
        move: [
          { source: './src/demo1.zip', destination: './dest/demo.zip'}
        ]
      }
    })
  ]
}
```

- `source {String}`: Moved source path.
- `destination {String}`: Moved destination path.

#### `rename` example

```javascript
module.exports = {
  plugins: [
    new FileManagerPlugin({
      end: {
        rename: [
          { source: './rename/b', destination: './rename/a' }
        ]
      }
    })
  ]
}
```

- `source {String}`: Renamed source path.
- `destination {String}`: Renamed destination path.

# Support
[webpack](https://www.npmjs.com/search?q=keywords:webpack)

[gulp](https://www.npmjs.com/search?q=keywords:gulp): During planning

[rollup](https://www.npmjs.com/search?q=keywords:rollup): During planning

# Development Setup
```text
# install deps
npm install

# build lib files
npm run build

# run example to see result
cd example
npm run start

# run unit test
npm run test

# show coverage report
npm run test:coverage

# watch unit test
npm run test:watch
```

repository: SoleilQ/filemanager-plugin

repo_name: SoleilQ/filemanager-plugin


text:
# Anne

Teams up with rubocop to prevent bad commits. Run rubocop on the files you've recently changed.

This is super basic so far and needs a lot of work. It assumes things about your system and doesn't handle its own dependencies.

```
$ gem install anne
$ anne
```

I'm sorry.

repository: jsrn/anne

repo_name: jsrn/anne


text:
# vue-sfc-cli

[![Build Status](https://badgen.net/travis/FEMessage/vue-sfc-cli/master)](https://travis-ci.com/FEMessage/vue-sfc-cli)
[![NPM Download](https://badgen.net/npm/dm/vue-sfc-cli)](https://www.npmjs.com/package/vue-sfc-cli)
[![NPM Version](https://badge.fury.io/js/vue-sfc-cli.svg)](https://www.npmjs.com/package/vue-sfc-cli)
[![NPM License](https://badgen.net/npm/license/vue-sfc-cli)](https://github.com/FEMessage/vue-sfc-cli/blob/master/LICENSE)
[![Automated Release Notes by gren](https://img.shields.io/badge/%F0%9F%A4%96-release%20notes-00B2EE.svg)](https://github-tools.github.io/github-release-notes/)

vue-sfc-cli is a powerful tool for developing vue single-file component.

It makes writing docs and demo easily, integrated with an automated github workflow, and is always ready to publish to npm with best practices.

[中文文档](./README-zh.md)

## Table Of Contents

- [Links](#links)
- [Notice](#notice)
  - [Requirement](#requirement)
  - [Prettier and husky](#prettier-and-husky)
  - [Stylelint](#stylelint)
  - [Windows](#windows)
- [Tutorial](#tutorial)
  - [Quick Start](#quick-start)
  - [Options](#options)
  - [Writing Example](#writing-example)
  - [API Documentation](#api-documentation)
    - [Props](#props)
    - [Slot](#slot)
    - [Event](#event)
    - [Methods](#methods)
  - [Working with third-party library](#working-with-third-party-library)
  - [Environment variable](#environment-variable)
- [Contributors](#contributors)

## Links

- [medium article](https://medium.com/deepexi/reveal-the-secret-of-vue-sfc-cli-69f0f21dbad3)

## Notice

### Requirement

Node.js 8.x

### Prettier and husky

The component template has built-in prettier and husky setup that can format code when you commit.

However, you need to execute commands as following, otherwise the commit hook will not take effect:

```sh
npx vue-sfc-cli

# git init must run before yarn
git init

yarn
```

### Stylelint

The component template has built-in stylelint, which perfectly supports less/sass, but not stylus(it cannot have comment)

### Windows

It is not recommended to generate components under Windows, cause `.sh` files may lost execution permissions.

## Tutorial

### Quick Start

```
npx vue-sfc-cli

# Next there will be a bunch of tips, please be sure to fill out
# Recommend kebab-case style, lowercase letters, multiple words separated by - (dash), such as my-component

# After filling the prompt
cd my-component

# Use git to initialize, so you can use the commit hook
git init

# Install dependency
yarn

# Develop component
yarn dev

# Build
yarn build

# Ready to publish!
# Or use `npm publish`
yarn publish
```

### Options

`-u`, `--upgrade`

According to the template files in the templates directory, new files will be generated and override the files with same name in current component directory. The default override files is defined in update-files.js. This option often used to upgrade the configuration of old components using the latest version of vue-sfc-cli：

**This option can also help any node.js project to set up configuration of AUTO npm publishment via travis ci**

```
# cd my-component
npx vue-sfc-cli -u
```

`--files`

If you want to update additional files, you can pass this option, multiple files use `,` to separate

```
npx vue-sfc-cli -u --files .babelrc.js,.eslintrc.js
```

`--test`

Generate a component template for testing, commonly used in CI.

```
npx vue-sfc-cli --test
```

`-o`, `--output`

Generate a component template in the specific output dir.

```
npx vue-sfc-cli --output ./outDir
```

`--name`, `--owner`

These two arguments are usually used together to generate component without prompt.

```
npx vue-sfc-cli --name log-viewer --owner FEMessage
```

### Writing Example

The docs directory hosts your component's examples. You just write markdown files, and they will turn into demo. It is also recommended to name the markdown files in kebab-case style.

Take the docs/draggable.md file of [upload-to-ali](https://github.com/FEMessage/upload-to-ali), the upload component as an example.

````
draggable example

```vue
<template>
  <upload-to-ali :preview="false" v-model="url" multiple />
</template>

```
````

`yarn dev` can turn this markdown file into live demo, which will show you what the component looks like and it's actual code. You can also modify the code and the demo can hot reload.

![image.png](https://cdn.nlark.com/yuque/0/2019/png/160590/1561702364721-6489a2cd-d21e-4382-b201-f9e6d1b5b022.png?x-oss-process=image/resize,w_1492)

### API Documentation

You can simply write comments in vue file to generate API documentation.

#### Props

Use multiple lines of comments in props

```
props: {
    /**
     * is upload multiple files
     */
    multiple: {
      type: Boolean,
      default: false
    },
}
```

#### Slot

On the slot line, use the comment at the beginning of @ slot

```
<!--@slot custom loading content -->
<slot name="spinner">
  <div class="upload-loading">
    <svg class="circular" viewBox="25 25 50 50">
      <circle class="path" cx="50" cy="50" r="20" fill="none"></circle>
    </svg>
  </div>
</slot>
```

#### Event

Use multi-line comments above the emit event

```
/**
 * @property {string} name - file name
 */
this.$emit('loading', name)
```

#### Methods

Above the method to be show in API doc, use multi-line comments and add @public

```
/**
 * trigger select files
 * @public
 */
selectFiles() {
  this.$refs.uploadInput.click()
},
```

preview like this

![image.png](https://cdn.nlark.com/yuque/0/2019/png/160590/1562220787035-7da78cf9-ef5c-49d8-83b1-8cc296aa9add.png?x-oss-process=image/resize,w_1492)

![image.png](https://cdn.nlark.com/yuque/0/2019/png/160590/1562220837322-f67bca09-e910-47e8-aa74-32cde527a4c8.png?x-oss-process=image/resize,w_1492)

### Working with third-party library

To [Element-UI](https://element.eleme.io/) As an example

```
yarn add element-ui
```

Add a file: `styleguide/element.js`

```
import Vue from 'vue'
import Element from 'element-ui'
import 'element-ui/lib/theme-chalk/index.css'
 Vue.use(Element)
```

Modify configuration files: `styleguide.config.js`

```
module.exports = {
  // ...
  require: [
    './styleguide/element.js'
  ]
}
```

if you need bundle in element components, you may refer the following code

```js
// rollup.config.js
import vue from 'rollup-plugin-vue'
import babel from '@rollup/plugin-babel'
import commonjs from '@rollup/plugin-commonjs'
import {terser} from 'rollup-plugin-terser'
import {nodeResolve} from '@rollup/plugin-node-resolve'
import json from '@rollup/plugin-json'
import css from 'rollup-plugin-css-only'
import copy from 'rollup-plugin-copy'
import minimist from 'minimist'

const argv = minimist(process.argv.slice(2))

const config = {
  input: 'src/index.js',
  output: {
    name: 'MyComponent',
    exports: 'named'
  },
  external: ['vue', 'vuex', 'axios', 'js-cookie', 'vue-clamp'],
  plugins: [
    json(),
    nodeResolve({extensions: ['.js', '.jsx', '.es6', '.es', '.mjs', '.vue']}),
    commonjs(),
    css({
      output: 'index.css',
    }),
    vue({
      css: false,
      compileTemplate: true,
      style: {
        postcssPlugins: [require('autoprefixer')]
      }
    }),
    babel({
      babelHelpers: 'runtime',
      extensions: ['.js', '.jsx', '.es6', '.es', '.mjs', '.vue'],
      exclude: 'node_modules/**'
    }),
    copy({
      targets: [
        {
          src: 'node_modules/element-ui/lib/theme-chalk/fonts/**/*',
          dest: 'dist/dist/fonts'
        }
      ]
    })
  ]
}

// Only minify browser (iife) version
if (argv.format === 'iife') {
  config.plugins.push(terser())
}

export default config
```

### Environment variable

If you need to use environment variables, it is recommended to use `dotenv`

```
yarn add dotenv --dev
```

```
// styleguide.config.js
const webpack = require('webpack')
const dotenv = require('dotenv')

module.exports = {
  webpackConfig: {
    // ...
    plugins: [
      new webpack.DefinePlugin({
        'process.env': JSON.stringify(dotenv.config().parsed)
      })
    ]
  }
}
```

## Contributors

Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):

levy
💻 🖋 🌍 🤔 👀

EVILLT
💻 🐛 ⚠ 🚧

Donald Shen
💻 ⚠

ColMugX
💻

This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!

repository: FEMessage/vue-sfc-cli

branch_name: refs/heads/dev

gha_language: JavaScript

repo_name: FEMessage/vue-sfc-cli


text:
# log-analyzer

# how to run main tool (gitbash shell)
./gradlew -Pparams="logfile.txt" bootRun

NB: Execute permissions are set on gradlew in the git repo so it should not be necessary to chmod +x gradlew, locally, after cloning the repo.

# how to run all tests
./gradlew test

# how to use util program to generate a text log file
./gradlew -Pparams="output.json" runLogGenerator

# todos
*Checked in my test local hssqldb files so you can view the insert stmts etc

*Tested with large "Generated" file of 147MB... no issues.. You can use the above runLogGenerator target to generate whatever size file you want although need to change the batch count and batch size in the code.. sorry ;)

*Its possible to run both the generator and the analyzer at the same time in two different consoles (or one as a background process), working on the same never ending file.

*Todos... continue to add UT/IT coverage around algorithm as noted in Listener Test


text:
# StarryNight Documentation

StarryNight are Monte Carlo codes to simulate dipole-dipole interactions and
(anti-)ferroelectric domains in a hybrid organic-inorganic perovskite solar cell.

This is (currently) achieved with the Metropolish algorithm. The simulation
volume is represented as a 3D lattice with individual sites posessing dipoles.
The Hamiltonian for the system is then the dipole-dipole interaction (summed to
a cut-off); a local 'cage strain' evaluated with the nearest neighbours
(motivated by ab-initio DFT calculations); and an applied field.
Random mixtures of dipoles of use specification can be used.

Though motivated by a mechanistic model of fixed methylammonium dipoles
rotating in 3D space, the same physics is produced by interacting dipoles of
e.g. Jahn-Teller distorted octahedra.

From the finite temperature Metropolis simulation, an electrostatic potential
can be reconstructed. This can then be used to infer device behaviour
(particularly, recombination and mobility).

The codes are written in C. They currently use a Mersenne-Twister
Pseudo-Random-Number-Generator to power the Metropolis algorithm.

## Publications

- [Molecular ferroelectric contributions to anomalous hysteresis in hybrid perovskite solar cells](http://scitation.aip.org/content/aip/journal/aplmater/2/8/10.1063/1.4890246) APL Materials (2014)
- [The dynamics of methylammonium ions in hybrid organic–inorganic perovskite solar cells](http://www.nature.com/ncomms/2015/150529/ncomms8124/abs/ncomms8124.html) Nature Communications (2015)
- [Role of microstructure in the electron–hole interaction of hybrid lead halide perovskites](http://www.nature.com/nphoton/journal/v9/n10/abs/nphoton.2015.151.html) Nature Photonics (2015)

## Development Notes

2016 - Master has now been moved to the Icarius branch, the 2014-2015 extension
to 3D, solid solutions, many further analysis tools, electrostatic potentials,
Fermi-Dirac/Boltzmann hole/electron populations.

2014-05-31 - Started work on Icarius

2014-01-29
Added dependency on libconfig for lightweight config file parsing.
Mac OSX: `brew install libconfig`
Debian: `sudo apt-get install libconfig-dev`

repository: sunatthegilddotcom/StarryNight

repo_name: sunatthegilddotcom/StarryNight


text:
# Home work tasks

## Homework 1

- Create iterator class. for..of loop should working similar with for..in loop.

## Homework 2
- Create fake rest api based on setTimeout or setInterval. It obtains data and after random time send promise response. If obtained string contains world error promise rejected.
- Create 7 requests in parallel. Then aggregate them results and push them to another request.
- After last request obtain results and push them to 3 different request and get the fastest response.

## Homework 3
- Create site used jQuery.Site one form with jQuery validation(email, phone number).
- Site should be bundled by webpack. You have to set version (increment) of bundle. Include all scripts not by the hands. All scripts should by minifiing and uglify. Sours maps should be included.

## Homework 4
- Create day ceil(functional) component.
- Component should retrieve as props day number and is this day is vacation

## Homework 5
- Create calendar component.
- It has to contains day components from pervious HW4
- All days components should be in month/year component
- you can switch month and days should change their order and numbers and days status(holiday/regular)
- get holidays from different public APIs using fetch(in can be fake API)
- you can change year
- Use redux approach

## Homework 6
- Create colored chess board
- Board shoul placed on the middle on thr device
- All ceils should be colored(color generated by random, nearest ceils can't have the same color)


text:
# Image Lazy Loading

Images are lazy loaded in the browser based on scroll position.  When the user scrolls to within 200px of the image, the image will be loaded onto the page. For carousels, the second pagination is loaded when the first page reaches within 200px of the viewport, while subsequent pages load when the previous page is loaded.  Using the dots to directly go to page will also trigger images on that page to load.

# Usage

```html
<hl-image src="http://ebay.com/image.jpg"
          alt="Image"
          class="hl-demo-image" >
</hl-image>
```

Lazy loading is done through the `<hl-image>` tag, which also ensures image sizing responsiveness.

Images added through the `<hl-image>` tag is displayed as the background of the parent `div`. Nested in the container div is an empty `div` that serves as the grey placeholder background when we're waiting for an image to finish loading and a blank `img`.  This `img`'s `src` points to a 1x1px static image. When this image loads, it's `onload` event handler adds the element to a lazy loading queue.  When the user scrolls, we iterate through the queue (`handler()`), check for images that needed to be loaded (`loadImageIfVisible(image, i)`), and emit a `lazyload` event to the image that tells it to load.

Image loading (`loadImage(e)`) is done by attaching a new `onload` handler to the placeholder image that sets the parent `div`'s `background` to be the same as the placeholder image's source.  We then set the placeholder image's src to be image we want to load, stored on its `data-src` attribute. This triggers the new `onload` handler, and we remove the image from the queue.

For carousels, we manually trigger the `lazyload` event on images.  For the second pagination, this happens when the first image on the first page loads. Other paginations wait for the user to click the next page or one of dots.

## Testing

Run the tests with `grunt fe-test --files='src/components/utils/lazy-load-images/fe-test/*.js'`

repository: FangJiFeiJennifer/StudyCode

repo_name: FangJiFeiJennifer/StudyCode


text:
---

title: Say Hello to Offline First
author: Alex
layout: blog-post
comments: true

---

Prescript: Join the discussion on [offlinefirst.org][1] and help collecting information on the [Offline First Github Organisation][2]. And see the two follow up articles [Offline First and the Circle Of Web][3] and [Offline First and the Circle of Web Part II: Breaking the Circle][4].

([Russian translation][5] by [@kouprianov][6])

* * *

*Sponsor message: if you are looking for professional services or consulting around all things Offline First, look no further than [Neighbourhoodie Software](http://neighbourhood.ie/), the initiators of the Offline First movement. They can help with anything from planning, design, UX, develpment and production support of small and large-scale offline apps.*

* * *

The members of [Team Hoodie][7] are currently travelling around quite a bit, organising, participating in and attending conferences and workshops in various countries, and through all this we've not only made lots of personal experiences with limited network connectivity, but also met many people from all over the world, all with their own related stories and problems.

**Frequently not having any data connection in even the wealthiest and most developed cities of the world has led us to conclude that no, the mobile connectivity/bandwidth issue isn't just going to solve itself on a global level anywhere in the near future.**

![](/blog/images/201311/tube.jpg)

We've generally been rather optimistic about the whole problem, often thinking that coverage and bandwidth are sure to increase continually, but our recent experiences have made this attitude appear increasingly naïve. Capacity problems, varying coverage and zones with **zero reception, unreliable connections** (both wifi and telco) and problems incurred through travelling will likely persist for quite a while.

**Geography is non-negotiable**, as is most architecture. Travellers are doubly plagued: not only by their mode of transport often prohibiting any sort of connection (many subways and high-speed trains come to mind, as do most airlines), but also by the extortionate roaming charges imposed by the carriers, making a spy-sized collection of SIM cards a neccessity for anyone without a massive personal telco budget. And this is speaking from a solidly western-europe-centric perspective.

[Gregor][9] has spent the last six weeks travelling through Africa on the [AfricaHackTrip][10], and we've had the opportunity to speak to people from all over the world at [Mozfest in London][11]. Here and in many other instances we've encountered a solid interest in and a passionate desire for better offline capability in both web and native applications.

## We can't keep building apps with the desktop mindset of permanent, fast connectivity, where a temporary disconnection or slow service is regarded as a problem and communicated as an error.

Mobile networks simply don't provide that same level of quality and consistency, and it's high time we start adapting to that reality. In the same way it makes sense to build interfaces mobile-first, it's time to think about designing and building our applications offline-first. With an offline mode that isn't merely a contingency for an error scenario, but a fundamentally more flexible and fault-tolerant way of application design.

With [Hoodie][7], we've created an architecture that allows you to build offline apps with relative ease. There are a few issues, but we're quite confident about the technical aspects of our syncing engine and how it handles being offline. But now we've stumbled on a plethora of new, hitherto unknown and unresearched use cases and UX scenarios, all of which are only now easily within the reach of most developers.

![](/blog/images/201311/hiking.jpg)

This is quite literally a new frontier, largely unexplored and full of interesting problems and unimagined edge cases. In most other realms of app design we are spoilt with UX/UI patterns we can readily employ, but offline-first is *terra incognita,* there is practically nothing to go on in terms of patterns and metaphors.

# Offline Becomes Reality

All of a sudden, offline becomes more than error handling. Offline becomes a non-threatening reality in which, yes, some aspects of your app will neccessarily stop working, but many others don't, because they no longer have to. And this raises many fundamental questions:

> Does the app even need to inform the human of the current connection state? Is this information even relevant to the human? If so, how can this best be done?

> Can I give the users more trust in the app, leaving them safe in the knowledge that it won't forget the last state it was in, and that it won't lose any data, regardless of what the connectivity situation is?

> How can I communicate to the human that creating data within the app is still possible offline, and that it will be posted/dispatched/properly dealt with in the future?

> How can my interface convey changes that occur in the users' current view when they reconnect and the server pushes new and changed data? What to do with deleted items, things that can't be organised in lists, objects that aren't in themselves immutable (like emails)?

> How can I make the inevitable resolution of conflicts by the human as painless and intuitive as possible?

> Can the app make any preemptive decisions on the part of the human and pre-load any low-overhead data they might need later?

> What metrics (possibly behavioural) are there to base these decisions on?

> How can I word all of these scenarios in a way that doesn't worry the users, that embraces offline as an unproblematic reality?

There's more, of course, but we have to start somewhere. [Our Mozfest session on Offline First Application Design][13] has made this abundantly clear to us. There's a whole new paradigm rolling our way, and we're going to roll with it. We want to help users of Hoodie in building robust, always-usable applications, not just on a technical level, but also with patterns, metaphors and methods for higher-level application, user experience and interface design. This will be our research project, and it's going to live at [offlinefirst.org][14].

If you are interested in joining the conversation, you can start by leaving comments on this post. We are looking forward about what you have to share! :)

![](/blog/images/201311/sailing.jpg)

[1]: http://offlinefirst.org
[2]: https://github.com/offlinefirst
[3]: http://blog.hood.ie/2013/11/offline-first-and-the-circle-of-web/
[4]: http://blog.hood.ie/2013/12/offline-first-and-the-circle-of-web-part-ii-breaking-the-circle/
[5]: http://habrahabr.ru/post/201004/
[6]: https://twitter.com/kouprianov
[7]: http://hood.ie "Hoodie"
[8]: http://www.flickr.com/photos/rudlavibizon/1213670748/ "Tube by rudlavibizon, on Flickr"
[9]: https://twitter.com/gr2m/ "Gregor Martynus on Twitter"
[10]: http://africahacktrip.org "AfricaHackTrip"
[11]: https://twitter.com/gr2m/ "Mozilla Festival"
[12]: http://www.flickr.com/photos/peterv/93463384/ "Hiking up Needle Point by 2sirius, on Flickr"
[13]: https://festival.etherpad.mozilla.org/mobile-designing-offline-first-web-apps "Offline First Application Design"
[14]: http://offlinefirst.org "Offline First"
[15]: http://www.flickr.com/photos/80471081@N04/8385628381/ "sailing boat by elisaboba, on Flickr"

branch_name: refs/heads/gh-pages

gha_language: HTML


text:
# My OC

My OC is a local app (build with symfony) to help mentors.

![image](https://user-images.githubusercontent.com/1884209/84604008-5eac5800-ae93-11ea-942f-b73a818e6544.png)

## Requirements

- PHP 7.2.5 or higher
- SQL Database
- [Composer](https://getcomposer.org/)

## Installation

#### Clone or download this repository

```bash
$ git clone git@github.com:XenoX/my-oc.git
```

#### Install dependencies

```bash
# in project directory
$ composer install
```

#### Set env vars

 ```bash
 $ cp .env .env.local
 ```

Go to `.env.local` file and set :

```bash
DATABASE_URL # Generally change only db_user, db_password and db_name
OAUTH_OC_CLIENT_ID # On OC website (logged), type App.api.anonymous.client_id on console
OAUTH_OC_CLIENT_SECRET # On OC website (logged), type App.api.anonymous.client_secret on console
```

#### Set up database

```bash
$ php bin/console doctrine:database:create
$ php bin/console doctrine:migrations:migrate
```

#### Launch server

❗[Symfony binary](https://symfony.com/download) required

```bash
$ symfony server:start
```

## Contributing

Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.

Please make sure to update tests as appropriate.

## License
[MIT](https://choosealicense.com/licenses/mit/)

repository: LeroyErwan/my-oc

repo_name: LeroyErwan/my-oc


text:
# Dice-challenge-refresh
This project is based on html css and javascript.To explore and learn more in javascript I made this webpage where u can play a small game.Refreshing your page changes the values of the dice which decided which player wins.

 link of game : https://abhishekgoyal17.github.io/Dice-challenge-refresh/


text:
# Advanced Samvera Camp 2018 Team 2 code repo

[![Build Status](https://travis-ci.org/RepoCamp/ascteam2.svg?branch=master)](https://travis-ci.org/RepoCamp/ascteam2)
[![Coverage Status](https://coveralls.io/repos/github/RepoCamp/ascteam2/badge.svg?branch=add-coveralls-support)](https://coveralls.io/github/RepoCamp/ascteam2?branch=add-coveralls-support)

We encourage particpation from throughout the library and opensource communities.  In order to ensure that everyone can enjoy a safe, welcoming, and resprectful enviornment, please familiarize yourself with the [Samvera Community Code of Condct](https://wiki.duraspace.org/display/samvera/Code+of+Conduct).

For more information on how to use this repository, please visit the [WIKI](https://github.com/RepoCamp/asc2018/wiki).

## Development Setup

First, ensure you can checkout the project and run the test suite:

```sh
$ git clone https://github.com/RepoCamp/asc2018.git camping; cd camping
$ bundle install
$ bin/rails ci
```

You should see a single passing test.

Review the [Hyrax prerequisites](https://github.com/samvera/hyrax/#prerequisites). You will need to have items 4--7 installed locally (Solr, Fedora, and SQLite are provided).

Now try standing up the development server. Make sure Redis is running (`$ redis-server`) and then do:

```sh
$ bin/rails hydra:server
```

And in a separate terminal:

```sh
$ bin/rails db:setup
$ bin/rails hyrax:default_admin_set:create
```

Make sure you have Redis running (in another separate terminal):

```sh
$ bundle exec redis-server
```

By default we are using Sidekiq in the development environment for background
jobs. You'll need to have it running in another tab:

```sh
sidekiq
```

At this point, you should be able to browse to `http://localhost:3000`, create a new user and deposit an item.

gha_language: Ruby


text:
# WCSessionFileTransfer-NSProgress
Drop-in NSProgress backport in WatchConnectivity for iOS 11 and lower & watchOS 4 and lower with Sample Project

Extra delegate function added for both watchOS and iOS:

```
- (void) session:(WCSession *)session didBeginIncomingTransfer:(WCSessionFileTransfer *)fileTransfer;
```

This will allow you to monitor the progress of receiving a file via WatchConnectivity just like you can for sending.

## USAGE:

Monitor NSProgress just like you would on iOS 12/watchOS 5 with the additional option to monitor an incoming transfer:

```
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object
                        change:(NSDictionary *)change context:(void *)context {

    if (context == ProgressObserverContext) {
        [[NSOperationQueue mainQueue] addOperationWithBlock:^{
            NSProgress *progress = object;
            NSLog(@"[NSProgress] Fraction sent : %f", progress.fractionCompleted);
        }];

        return;
    }

    if (context == ProgressObserverContextIncoming) {
        [[NSOperationQueue mainQueue] addOperationWithBlock:^{
            NSProgress *progress = object;
            NSLog(@"[NSProgress] Fraction received : %f", progress.fractionCompleted);
        }];
        return;
    }

    [super observeValueForKeyPath:keyPath ofObject:object change:change context:context];
}
```

### iOS

```
static void *ProgressObserverContext = &ProgressObserverContext;

WCSessionFileTransfer *transfer = [_session transferFile:fileURL metadata:@{@"key" : @"value"}];

//Suppress @available iOS 12 warning (optional)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunguarded-availability-new"

[transfer.progress addObserver:self
                    forKeyPath:NSStringFromSelector(@selector(fractionCompleted))
                       options:NSKeyValueObservingOptionInitial
                       context:ProgressObserverContext];

#pragma clang diagnostics pop
```

### watchOS

```
static void *ProgressObserverContextIncoming = &ProgressObserverContextIncoming;

- (void) session:(WCSession *)session didBeginIncomingTransfer:(WCSessionFileTransfer *) fileTransfer {

    //Suppress @available watchOS 5.0 warning (optional)
    #pragma clang diagnostic push
    #pragma clang diagnostic ignored "-Wunguarded-availability-new"

    [fileTransfer.progress addObserver:self
                            forKeyPath:NSStringFromSelector(@selector(fractionCompleted))
                               options:NSKeyValueObservingOptionInitial
                               context:ProgressObserverContextIncoming];

    #pragma clang diagnostics pop

}
```


text:
# This is my first Git Project
  *As you can see this project contains two files:*
  1. HelloJava
  2. HelloWorld

  The first file will finally be a windows-program and the second file is just a test which is useless.

# Update Log

- 2019.4.6
   -
Using Git as my version Contron colloection,and in the end I want to Contron My Project on the GitHub then the homework in the school and so on can be easily organized through The Git!Sounds awesome :XD

   - Using a better algorithm to optimize the **moveData** method in class HelloJava2 which time complexity is O(n) and space complexity is O(1)。(An nice idea comes from QuickSort :))

---


text:
Dropbeat
========

Dropbeat is online music player that lets you listen to music in online streaming sources better.

We all are tired of pressing refresh button to repeat youtube music and seeing commercial ads on youtube.

Furthermore, clicking favorite soundcloud tracks on my chrome bookmarks always makes me angry.

I'm a developer who loves music, especially EDM.

`Dropbeat` is the manifestation of my interest to make a better interface to enjoying streaming music.

License
=======

This project is licensed under MIT License.

Authors
=======

Park Ilsu [@daftshady](http://github.com/daftshady) - Original developer

Lee Teksu [@teksu](http://github.com/teksu) - High performance developer passionate about UI/UX

repository: youngilcho/dropbeat

repo_name: youngilcho/dropbeat


text:
---
layout: creature
name: "Sparking Alchemist"
tags: [medium, humanoid, cr2, nerzugals-extended-bestiary]
cha: 6 (-2)
wis: 12 (+1)
int: 16 (+3)
con: 14 (+2)
dex: 14 (+2)
str: 10 (+0)
size: Medium humanoid
alignment: chaotic evil
challenge: "2 (450 XP)"
languages: "--"
senses: "passive Perception 11"
damage_immunities: "lightning"
speed: "30 ft."
hit_points: "39 (6d8 + 12)"
armor_class: "12"
---

***Spellcasting.*** The alchemist is a 3rd-level spellcaster. His
spellcasting ability is Intelligence (spell save DC 13, +5
to hit with spell attacks). He has the following Wizard
spells prepared:

* Cantrips (at will): mage hand, shocking grasp

* 1st level (4 slots): chromatic orb, magic missile, witch bolt

* 2nd level (3 slots): mirror image, shatter

### Actions

***Multiattack.*** The alchemist makes two attacks with its
sparking strike.

***Sparking Strike.*** Melee Weapon Attack: +3 to hit, reach
5ft., one target. Hit: 2 (1d4) bludgeoning damage plus
3 (1d6) lightning damage.

gha_language: CSS


text:
# Bamazon
A back-end application for a store front, using MySQL and Javascript.

###Set Up

 * You will need to install Node before you can use this project. You can find Node at the following link [https://nodejs.org/en/download/]

 * You will also need to install MySQL onto your computer. You can find MySQL at the following link [https://www.mysql.com/downloads/]

 * It may be worth your time to set up MySQL workbench, although this is not requried. If you have set up your class paths correctly you should have access to MySQL from the command line. Still, some people prefer to work with a GUI, and if you are one of those folks, you can find MySQL workbench at the following link [https://www.mysql.com/products/workbench/]

 * To use this application, you will need to set up the node modules. This can be done by performing the following steps

    1. Open the command line

    2. navigate to the directory of the cloned Bamazon application

    3. type in either of the following commands into the command line

    ```
    npm install

    npm i
    ```

 * You will also have to set up the database. This can be done at the command line by typing in the following command

    ```
    mysql < bamazon.sql
    ```

    * You are effectively telling your OS to feed in the script into the MySQL application. This should seed the intial database for Bamazon.

 * If you find yourself being denied access to MySQL, chances are you set up a password for your database. The error might look something like

    ```
    ERROR 1045: Access denied for user
    ```

    * In this case you can try the following  command

    ```
    mysql -u root -p < bamazon.sql
    ```

    * The difference is you are setting the user to 'root' and you will be prompted to enter your password

 * Didn't remember your password? I'm afraid you may have to uninstall and then re-install MySQL. At least it should be easier installing the software a second time.

 * As an alternative, you can try to set up MySQL workbench and run the script 'bamazon.sql' using the GUI.

 * One last thing, you will need to set up a .env file. This is referenced in all of the scripts and will contain the password for MySQL. Without the file the scripts will not function as intended.

    * To set up the file, create a file with the name '.env' within the main directory of the Bamazon application

    * Then add the following text to the file

    ```javascript
    SQL_PASS=your-password-here
    ```

    * If you did not set up a password, that's ok. You will still need to set up this file. Simply add the following text instead

    ```javascript
    SQL_PASS=
    ```

    * The scripts will need a variable to reference, even if nothing is being stored in that variable. Otherwise you might recieve errors when running the scripts.

### Running a script

 * To run the scripts, simply type in one of the following command

 ```
 node bamazonCustomer.js

 node bamazonManager.js

 node bamazonSupervisor.js
 ```

 * When the scripts run, they should prompt you for the correct input, and update the databases apporpriately

 * Below are some screenshots of the scripts being run

### Screenshots

 * Purchasing a product

 ![alt text][customer01]

 * Database is updated after purchasing a product

 ![alt text][customer02]

 * Viewing the product list

 ![alt text][manager01]

 * Viewing the products that have low inventory

 ![alt text][manager02]

 * Adding to the inventory of a product

 ![alt text][manager03]

 * Database is updated after adding to the inventory of a product

 ![alt text][manager04]

 * Add a new product to the inventory

 ![alt text][manager05]

 * Database is updated after adding a new product to the inventory

 ![alt text][manager06]

 * View product sales by department

 ![alt text][supervisor01]

 * Create a new department

 ![alt text][supervisor02]

 * Database is updated after creating a new department

 ![alt text][supervisor03]

[customer01]: ./images/customer01.PNG "Purchasing a product"
[customer02]: ./images/customer02.PNG "Database is updated after purchasing a product"

[manager01]: ./images/manager01.PNG "Viewing the product list"
[manager02]: ./images/manager02.PNG "Viewing the products that have low inventory"
[manager03]: ./images/manager03.PNG "Adding to the inventory of a product"
[manager04]: ./images/manager04.PNG "Database is updated after adding to the inventory of a product"
[manager05]: ./images/manager05.PNG "Add a new product to the inventory"
[manager06]: ./images/manager06.PNG "Database is updated after adding a new product to the inventory"

[supervisor01]: ./images/supervisor01.PNG "View product sales by department"
[supervisor02]: ./images/supervisor02.PNG "Create a new department"
[supervisor03]: ./images/supervisor03.PNG "Database is updated after creating a new department"

repository: RexStrider/Bamazon

repo_name: RexStrider/Bamazon


text:
[![Galaxy Tool Linting and Tests for push and PR](https://github.com/galaxyproject/galaxy-tool-repository-template/actions/workflows/pr.yaml/badge.svg?branch=main)](https://github.com/galaxyproject/galaxy-tool-repository-template/actions/workflows/pr.yaml/badge.svg)
[![Weekly global Tool Linting and Tests](https://github.com/galaxyproject/galaxy-tool-repository-template/actions/workflows/ci.yaml/badge.svg?branch=master)](https://github.com/galaxyproject/galaxy-tool-repository-template/actions/workflows/ci.yaml/badge.svg)

# Galaxy tool repository template

This is a template repository to create [IUC](https://github.com/galaxyproject/tools-iuc) style repositories.
It offers:

- the same structure as the IUC repository
- CI for pull requests and weekly CI for all tools

Some documentation of the structure and the use of the CI can be found in [here](TODO link to tutorial).

Setup
=====

- Adapt the repository owner from `galaxyproject` to the owner of your repository [here](https://github.com/galaxyproject/galaxy-tool-repository-template/blob/main/.github/workflows/ci.yaml#L15), [here](https://github.com/galaxyproject/galaxy-tool-repository-template/blob/main/.github/workflows/pr.yaml#L304) and [here](https://github.com/galaxyproject/galaxy-tool-repository-template/blob/main/.github/workflows/slash.yaml#L10). This is needed to forbid running the CI workflows in forks.
- Change the links for the badges in this document [here](https://github.com/galaxyproject/galaxy-tool-repository-template/blob/main/README.md#L1) and [here](https://github.com/galaxyproject/galaxy-tool-repository-template/blob/main/README.md#L2), i.e. chage the organisation and repository name in the links. Certainly you may want to add the other content of this document.
- Add the API keys to the toolshed and testtoolshed as secrets with the name `TTS_API_KEY` and `TS_API_KEY`.
- Remove the example tool in `tools/example`

In order to use the `/run-all-tool-tests` slash command you need to add a secret `PAT` to your repo that allows the action to access
you repository - see [here](https://docs.github.com/en/actions/reference/encrypted-secrets). The slash command allows to run trigger weekly CI running using a given fork and branch of the Galaxy project, e.g. `/run-all-tool-tests branch=release_21.05 fork=galaxyproject`.

Also consider adding:

- `CONTRIBUTING.md`
- `.github/CODEOWNERS`
- `.github/PULL_REQUEST_TEMPLATE.md`

Updates
=======

Only the CI workflows may require updates from time to time. You can manually copy the latest version from this repository to your repository (not changing the repository owner as indicated in the setup section). We suggest to do this at least once a year, ideally with every Galaxy release.

Bug reports
===========

Please report problems with the CI workflows here: [IUC](https://github.com/galaxyproject/tools-iuc).


text:
---
# Documentation: https://sourcethemes.com/academic/docs/managing-content/

title: "New York Undercover"
summary: ""
authors: []
tags: [TV_and_Movies]
categories: []
date: 1994-07-17T21:16:51-04:00

# Optional external URL for project (replaces project detail page).
external_link: ""

# Featured image
# To use, add an image named `featured.jpg/png` to your page's folder.
# Focal points: Smart, Center, TopLeft, Top, TopRight, Left, Right, BottomLeft, Bottom, BottomRight.
image:
  caption: ""
  focal_point: ""
  preview_only: false

# Custom links (optional).
#   Uncomment and edit lines below to show custom links.
links:
- name: IMDB
  url: https://www.imdb.com/title/tt0108876
  icon_pack: fab
  icon: imdb

url_code: ""
url_pdf: ""
url_slides: ""
url_video: ""

# Slides (optional).
#   Associate this project with Markdown slides.
#   Simply enter your slide deck's filename without extension.
#   E.g. `slides = "example-slides"` references `content/slides/example-slides.md`.
#   Otherwise, set `slides = ""`.
slides: ""
---

Producer and Writer, 1994-1995

- Catman Comes Back (1995) ... (supervising producer)
- Downtown Girl (1995) ... (supervising producer)
- Manchild (1995) ... (supervising producer)
- The Shooter (1995) ... (supervising producer)
- Olde Tyme Religion (1995) ... (supervising producer, story)
- Eliminate the Middleman (1995) ... (supervising producer)
- All in the Family (1995) ... (supervising producer, writer)
- CAT (1995) ... (supervising producer)
- Innocent Bystanders (1995) ... (supervising producer)
- You Get No Respect (1995) ... (supervising producer, story)
- Mama Said Knock You Out (1995) ... (supervising producer)
- The Smoking Section (1995) ... (supervising producer)
- Private Enemy No. 1 (1995) ... (supervising producer)
- Los Macheteros (1994) ... (supervising producer)
- Blondes Have More Fun (1994) ... (supervising producer, teleplay)
- Eyewitness Blues (1994) ... (supervising producer)
- Mate (1994) ... (supervising producer)
- The Friendly Neighborhood Dealer (1994) ... (supervising producer)

repository: rwward/rmw-site

repo_name: rwward/rmw-site


text:
# Invoice

This component displays the invoice

##### Detail

* Generate the `Invoice` Component

```
$ ng generate component invoice
```

##### Change the controller by editing the `invoice.component.ts` file

 1) add the `invoice` and `customer` variables

```typescript
  invoice: Invoice;
  customer: Customer;
```

 2) Edit the `constructor` by injecting the `InvoicesService`, the `InvoicesService` and `ActivatedRoute` that will allow us to retrieve the route parameter

```typescript
  constructor(
    private invoicesService: InvoicesService,
    private customersService: CustomersService,
    private route: ActivatedRoute) {
  }
```

3) Add code to the `nbOnInit()` function to retrive the customer data from it's :id:

```typescript
  ngOnInit() {
    this.route.params.pipe(
      map((params: Params) => params.invoiceId),
      switchMap(invoiceId => this.invoicesService.get<Invoice>(invoiceId)),
      map(invoice => {
        this.invoice = invoice;
        return invoice.customerId;
      }),
      switchMap(customerId => this.customersService.get<Customer>(customerId))
    ).subscribe(customer => {
      this.customer = customer;
    });
  }
```

* Final Result (Full Source Code)

```typescript
import {Component, OnInit} from '@angular/core';
import {Customer, CustomersService, Invoice, InvoicesService} from '../services';
import {ActivatedRoute, Params} from '@angular/router';
import {map, switchMap} from 'rxjs/operators';

@Component({
  selector: 'app-invoice',
  templateUrl: './invoice.component.html',
  styleUrls: ['./invoice.component.scss']
})
export class InvoiceComponent implements OnInit {

  invoice: Invoice;
  customer: Customer;

  constructor(
    private invoicesService: InvoicesService,
    private customersService: CustomersService,
    private route: ActivatedRoute) {
  }

  ngOnInit() {
    this.route.params.pipe(
      map((params: Params) => params.invoiceId),
      switchMap(invoiceId => this.invoicesService.get<Invoice>(invoiceId)),
      map(invoice => {
        this.invoice = invoice;
        return invoice.customerId;
      }),
      switchMap(customerId => this.customersService.get<Customer>(customerId))
    ).subscribe(customer => {
      this.customer = customer;
    });
  }

}
```

###### Change the template by editing the `invoice.component.html` file

* It will display the Invoice Component

```html
<mat-list *ngIf="invoice && customer">
  <h3 mat-subheader>Invoice ID: {{invoice.id}}</h3>
  <mat-list-item>
    <mat-icon mat-list-icon *ngIf="invoice.paid">done</mat-icon>
    <mat-icon mat-list-icon *ngIf="!invoice.paid">clear</mat-icon>
    <h4 mat-line *ngIf="invoice.paid">Payment Received</h4>
    <h4 mat-line *ngIf="!invoice.paid">Outstanding</h4>
    <p mat-line>Payment Status</p>
  </mat-list-item>
  <mat-list-item>
    <mat-icon mat-list-icon>done</mat-icon>
    <h4 mat-line>{{invoice.service}}</h4>
    <p mat-line>Service</p>
  </mat-list-item>
  <mat-list-item>
    <mat-icon mat-list-icon>date_range</mat-icon>
    <h4 mat-line>{{invoice.date | date}}</h4>
    <p mat-line>Date</p>
  </mat-list-item>
  <mat-list-item>
    <mat-icon mat-list-icon>schedule</mat-icon>
    <h4 mat-line>{{invoice.hours}} hours at {{invoice.rate | currency:'USD':'symbol-narrow':'.0'}}</h4>
    <p mat-line>Hours and Rate</p>
  </mat-list-item>
  <mat-list-item>
    <mat-icon mat-list-icon>attach_money</mat-icon>
    <h4 mat-line>{{invoice.hours * invoice.rate | currency:'USD':'symbol-narrow':'4.2-2'}}</h4>
    <p mat-line>Total Invoiced</p>
  </mat-list-item>
  <mat-list-item>
    <mat-icon mat-list-icon>perm_identity</mat-icon>
    <h4 mat-line>{{customer.name}}</h4>
    <p mat-line>Customer</p>
  </mat-list-item>
</mat-list>
```

##### Routing

1) Add the routing to `app-routing.module.ts` `routes` constant

```typescript
  { path: 'invoices/:invoiceId', component: InvoiceComponent },
```

* Final Result

```typescript
const routes: Routes = [
  { path: 'invoices', component: InvoicesComponent },
  { path: 'invoices/:invoiceId', component: InvoiceComponent },
  { path: '', pathMatch: 'full', redirectTo: '/invoices' },
];
```

2) Add the Router Link to `invoices.component.html` Master file

```html
routerLink="/invoices/{{invoice.id}}"
```

* Final Result

```html
<mat-list>
  <h3 mat-subheader>Recent Invoices</h3>
  <mat-list-item *ngFor="let invoice of invoices" routerLink="/invoices/{{invoice.id}}">
    <mat-icon mat-list-icon>folder</mat-icon>
    <h4 mat-line>{{invoice.service}}</h4>
    <p mat-line> {{invoice.date | date}} </p>
  </mat-list-item>
</mat-list>
```

[:fast_forward: Next ](invoice-form.md)

repository: CollegeBoreal/Tutoriels

gha_language: TypeScript

repo_name: CollegeBoreal/Tutoriels


text:
# fusionauth-example-python-hotspot

This project lets you configure a linux server as a wifi hotspot, and control access using FusionAuth accounts.

You can read the full blog post here: https://fusionauth.io/blog/2020/11/04/hotspot-authentication-with-fusionauth/


text:
# SAISandbox
"Semi" artificial intelligence sandbox

# Challenge

Decide a team to win and make it so!

# Factions

BrownRebelScumbagWithLaser aka Brown

WhiteManWithLazer aka White

# Rules

You can only modify challenge.py from this repository. Change the winning team of your choice by changing value of `WINNER` variable using enums defined `TEAMS` (WHITE or BROWN).

The run method from chosen team will be run on every loop on the main loop.

The team that should lose will stay put for the whole game.

# Methods

You can check the methods from models.py for more information. Basic methods that you can use are:

* move_left
* move_right
* move_up
* move_down
* shoot

All of the move methods will return False if there is an obstacle.

# Setup

1. Install git
2. Install python 2.7.x
3. Install python pip
4. Install pygame
5. Clone repository
6. run command `cd SAISandbox ; pip install -r requirements.txt`

# Run game

Use following command `python game.py` the game will automatically end after one of the teams is dead. The game will print to terminal "You win" or "You lose" depending if the team you decided to win actually won.

repository: Atihinen/SAISandbox

repo_name: Atihinen/SAISandbox


text:
# Create a read-only instance {#concept_ghp_wq5_vdb .concept}

You can create read-only instances to process massive read requests sent to the database and increase the application throughput. A read-only instance is a read-only copy of the master instance. Changes to the master instance are also automatically synchronized to all relevant read-only instances through the native replication capability of MySQL.

## Attention {#section_dbp_zq5_vdb .section}

-   Currently the following instances support read-only instances:
    -   MySQL 5.7 High-Availability Edition \(based on local SSDs\)
    -   MySQL 5.6
    -   SQL Server 2017
-   Quantity of read-only instances

    |Database type|Memory|Max number of read-only instances|
    |-------------|------|---------------------------------|
    |MySQL|≥ 64 GB|10|
    |< 64 GB|5|
    |SQL Server|Any|7|

-   Read-only instance is subject to an additional charge and its billing method is Pay-As-You-Go. For more information, see [Pricing](https://www.alibabacloud.com/en/product/apsaradb-for-rds?spm=a3c0i.o26117en.a3.1.FZgSTK#pricing) for read-only instances.
-   The read-only instance automatically copies the whitelist its master instance, but the whitelist of the read-only instance and that of the master instance are independent. To modify the whitelist of the read-only instance, see [Set a whitelist](intl.en-US/Quick Start for MySQL/Initial configuration/Set the whitelist.md#).

## Procedure { .section}

1.  Log on to the [RDS console](https://rds.console.aliyun.com/).
2.  Select the region where the target instance is located.
3.  Click the ID of the target instance to visit the Basic Information page.
4.  In the **Instance Distribution** area, click **Add Read-only Instance**, as shown in the following figure.

    ![](http://static-aliyun-doc.oss-cn-hangzhou.aliyuncs.com/assets/img/7827/15575426606172_en-US.png)

5.  On the purchasing page, choose the configuration of the read-only instance, and then click **Buy Now**.

    **Note:**

    -   We recommend that the read-only instance and the master instance be in the same VPC.
    -   To guarantee sufficient I/O for data synchronization, we recommend that the configuration of the read-only instance \(the memory\) is not less than that of the master instance.
    -   We recommend that you purchase multiple read-only instances to improve availability.
6.  Select **Product Terms of Service and Service Level Notice and Terms of Use**, and then click **Pay Now**.
7.  After creating the read-only instance, you can view it on the Instances page, as shown in the following figure.

    ![](http://static-aliyun-doc.oss-cn-hangzhou.aliyuncs.com/assets/img/7827/15575426602617_en-US.png)

url: https://raw.githubusercontent.com/aekinkjet30/mysql/c24752a07f2e288330d084215329d9225024200e/intl.en-US/RDS for MySQL User Guide/Read-only instances and read__write splitting/Create a read-only instance.md

filename: Create a read-only instance.md


text:
# pytorch-deeplab-xception

### Environment Configuration
The code was tested with Anaconda and Python 3.6.

1. Install dependencies:

    For PyTorch dependency:
    ```Shell
    conda install pytorch=0.4.1 cuda90 -c pytorch
    pip install torchvision==0.2.2
    ```

    For custom dependencies:
    ```Shell
    pip install matplotlib pillow tensorboardX tqdm scipy Cython
    ```

    ```Shell
    pip install pycocotools
    ```

### Dataset

1. download dataset:

    For VOC2012:
    ```Shell
    bash download_voc.sh
    ```

    For coco2017:
    ```Shell
    bash download_coco.sh
    ```

### Training
Follow steps below to train your model:

1. Input arguments: (see full input arguments via python train.py --help):
    ```Shell
    usage: train.py [-h] [--backbone {resnet,xception,drn,mobilenet}]
                [--out-stride OUT_STRIDE] [--dataset {pascal,coco,cityscapes}]
                [--use-sbd] [--workers N] [--base-size BASE_SIZE]
                [--crop-size CROP_SIZE] [--sync-bn SYNC_BN]
                [--freeze-bn FREEZE_BN] [--loss-type {ce,focal}] [--epochs N]
                [--start_epoch N] [--batch-size N] [--test-batch-size N]
                [--use-balanced-weights] [--lr LR]
                [--lr-scheduler {poly,step,cos}] [--momentum M]
                [--weight-decay M] [--nesterov] [--no-cuda]
                [--gpu-ids GPU_IDS] [--seed S] [--resume RESUME]
                [--checkname CHECKNAME] [--ft] [--eval-interval EVAL_INTERVAL]
                [--no-val]

    ```

2. (**Recommended**) To train deeplabv3+ using Pascal VOC dataset and **mobilenet** as backbone:
    ```Shell
    bash train_voc.sh
    ```
    Notice that GPU [0,1,2,3] are used default in train_voc.sh. You can change it as you wish.
3. To train deeplabv3+ using COCO dataset and **ResNet** as backbone:
    ```Shell
    bash train_coco.sh
    ```

repository: leeyegy/pytorch-deeplab-xception

repo_name: leeyegy/pytorch-deeplab-xception


text:
<h1 align="center">
Users api Nodejs
</h1>

This app using all the latest features, tools and practices in web development!

- :blue_book: **Typescript** — TypeScript provides highly productive development tools for JavaScript IDEs and practices, like static checking.
- 💹 **Node Js** — A open-source, cross-platform, JavaScript runtime environment that executes JavaScript code outside a web browser
- :notebook_with_decorative_cover: **MySql** — Oracle MySQL Database Service is a fully managed database service that enables organizations to deploy cloud native applications using the world’s most popular open source database.

## Getting started

1. Clone this repo using `https://github.com/wellingtonn96/challenge-backendInNodejs.git`
2. Move yourself to the appropriate directory: `cd challenge-backendInNodejs/`
3. Run `yarn install` to install dependences

### Getting started with the backend server

1. Create the database in the mysql
2. Configure the database in the `ormconfig.json` file
3. Run migrations with the command `yarn typeorm migration:run`
4. Move yourself to the server folder: `cd src/`
5. Run `yarn dev:server` to start the server

### See the documentation

**URL** : `http://localhost:3333/api-docs/`

### Testing the application

1. Test the application with the command `yarn test`


text:
# Profile Generator

  ![GitHub license](https://img.shields.io/badge/license-ISC-orange.svg)

  ## Description
  This is a Node.js command-line application that takes in information about employees on a software engineering team and generates an HTML webpage that displays summaries for each person. You can find details on how to use this app below.
  ## Table of Contents

  * [Installation](#installation)
  * [Usage](#usage)
  * [License](#license)
  * [Tests](#tests)
  * [Links](#links)

  ## Installation
  From my GitHub repository you can clone the source code, and then run an npm install jest and npm inquirer in your terminal.

  ## Usage
  Once you have installed each npm package, you can run the tests that are in the repo by opening the terminal in the root of your project and type 'npm run test'. After all 4 tests pass, you can then run 'node index.js' to start the CLI prompts. You will be directed to use your arrow keys to select list menu items, use all letter and number keys to enter question prompts, and the 'enter' key to submit each of your responses.

  ## License
  ISC

  ## Tests
  In order to run tests ensure that npm jest is installed on your local machine, then in the root of the code you can type 'npm run test' in your terminal.

  ## Links
  A walkthrough video demonstration of my project can be found here: https://drive.google.com/file/d/1vxgrMmCgi3Xv7zsxD5hmjhrigkavAwIF/view

license: ISC

repository: ashwarters/profilegenerator

repo_name: ashwarters/profilegenerator


text:
---
title: Slides Template
author: Minijackson
date: 2019-09-08
slide-level: 2
aspectratio: 169
theme: metropolis
toc: true

header-includes: |
  \usepackage{pgfpages}
  \setbeameroption{show notes on second screen=right}

  \usecolortheme{owl}
  \setbeamercolor{section in toc}{
    use=normal text,
    fg=normal text.fg
  }
  \setbeamercolor{subsection in toc}{
    use=normal text,
    fg=normal text.fg
  }

  \usepackage{fvextra}
---

<!-- Compile with:
`pandoc slides.md -t beamer slides.pdf --highlight-theme breezedark` -->

# In the morning

## Getting up

### It's hard

- Turn off alarm
- Get out of bed

## Breakfast

- Eat eggs
- Drink coffee

# In the evening

## Dinner

- Eat spaghetti
- Drink wine

## This frame {.standout}

This Is Important!™

. . .

This Is Important×2!™

---

This Is Important×3!™

## The End {.standout}

That's all folks!

. . .

Questions?

repository: minijackson/nixos-config

repo_name: minijackson/nixos-config


text:
# 2021 CFF Technical Oversight Committee Election Results

Many thanks to everyone who took the time to register and vote in the first Cloud Foundry Foundation annual election for our newly forming Technical Oversight Committee (TOC). I also extend my deep thanks to all of the nominees who agreed to run in the election. Overall, our community’s participation in this election process was outstanding (especially given that this was our first time doing this!)

And with that preamble, I’m pleased to announce our first CFF Technical Oversight Committee will be:

* Eric Malm (VMware)
* David Stevenson (VMware)
* Jan von Loewenstein (SAP)
* Stephan Merker (SAP)
* Lee Porte (GOV.UK)

Congratulations to Eric, David, Jan, Stephan and Lee! I’m looking forward to working with you to get the TOC up and running.

## Details

One of the [primary principles](https://github.com/cloudfoundry/community/blob/main/toc/PRINCIPLES.md) that our technical governance process is based on is transparency. That applies to the election process and results themselves, with the only exception being that ballot records are anonymous.

With that in mind, here are the election details:

Election Supervisor: Chip Childers

Announced end of poll: June 15, 2021

Actual time poll closed: 6/15/2021, 8:07:44 PM ET

Private poll (125 authorized voters)

Actual votes cast: 98

Complete results of the election, using the Schulze rules for Condorcet completion, are:

1. Eric Malm  (Condorcet winner: wins contests with all other choices)
2. David Stevenson  loses to Eric Malm by 62–22
3. Jan von Loewenstein  loses to Eric Malm by 73–22, loses to David Stevenson by 60–34
4. Stephan Merker  loses to Eric Malm by 70–25, loses to Jan von Loewenstein by 46–31
5. Beyhan Veli  loses to Eric Malm by 72–23, loses to Stephan Merker by 42–35
6. Lee Porte  loses to Eric Malm by 83–8, loses to Beyhan Veli by 48–41
7. Andrew Edgar  loses to Eric Malm by 82–10, loses to Lee Porte by 43–41
8. Daniel Vaughan  loses to Eric Malm by 90–1, loses to Andrew Edgar by 58–14

Our TOC rules for a maximum of 2 TOC members from the same employer must be applied to these results, placing Lee Porte on the TOC instead of Beyhan Veli.

Eric and David were the top two nominees of the group, meaning that both of them will have the full two year TOC member term. Jan, Stephan and Lee will each have a one year term, and their seats on the TOC will be up for election again in 2022. Keep in mind that this difference in term lengths only applies to this first election. In 2022, those three TOC seats will be elected for the standard TOC member term of two years. Of course, Jan, Stephan and Lee will be more than welcome to run in 2022.

Records of all cast ballots are available in [CSV format here](ballots.csv).

## 2022-05-17 Amendment

In the TOC meeting on May 17th, 2022, the TOC decided it would be more equitable to distribute the seats with the 2021-2023 terms evenly between the VMware and the SAP representatives. The TOC also decided to allocate the 2-year seat to Stephan Merker, since Jan von Loewenstein intends not to run for a continued position on the TOC after the 2021-2022 term.

repository: fifthposition/community

repo_name: fifthposition/community


text:
# Webpage_Text_Extraction

Extract main textual information from HTML.

## Requirement

* Python 3

## Installation

```shell
pip install pextract
```

## Example

```python
import requests
from bs4 import BeautifulSoup
import pextract as pe
from urllib.parse import urljoin

url = 'https://allaboutstevejobs.com/bio/short_bio'
r = requests.get(url)
soup = BeautifulSoup(r.content, 'lxml')
for img in soup.findAll('img'):
	img['src'] = urljoin(url, img['src'])
html, pval = pe.extract(soup, text_only = False, remove_img = False)
text, pval = pe.extract(soup)
print(pval) # This is a strong feature for web page classification
with open('out.html', 'w', encoding = 'utf-8') as f:
	f.write(html)
with open('out.txt', 'w', encoding = 'utf-8') as f:
	f.write(text)
```


text:
# Web-Data-Automated-Testing

This project demonstrates data/web testing automation via Selenium and BeautifulSoup.

Data integrity is a critical issue in the ear of big data.

Automating data testing can help improve the accuracy of our data system.

In this project, we use a popular financial website in Taiwan (i.e., www.simmcloud.com) and try to extract the data for testing.

For an abnormal value or unexpected exception, the system will send email to alert specific administrators

Feel free to give me any feedback. You can mailto<EMAIL_ADDRESS>
                                            Yu-Jia Chen   Taiwan, 08/25/2016, 7:47 PM

# Environment Setting
1. Install BeautifulSoup
2. Install Selenium
3. Install schedule


text:
3-proto-lisp
------------

Code from the paper _Reflection for the Masses_ ([PDF](http://www.p-cos.net/documents/s32008.pdf)) by Charlotte Herzeel, Pascal Costanza, and Theo D'Hondt.

## Getting Started
```common-lisp
(cl:in-package 3-proto-lisp)
(3pl:read-normalize-print)
;; evaluate examples.3pl in REPL
```

Play in your browser at [io.livecode.ch](http://io.livecode.ch/learn/namin/3-proto-lisp)!


text:
---
title: "Entity Framework 6 - speed up reading the data"
tags:
  - EF6
  - C#
---
If you want to read data from the database without need of editing it later you can improve your query by using the `AsNoTracking` method. This "read-only query" is quicker to execute because EF will no need to set up change tracking information about every single loaded entity.

To show you benefits from using `AsNoTracking` method I created a sample program. In my sample program, I read data from *AdventureWorks* database from the single table *TransactionHistory* (in this table is 113443 rows).  To measure performance I was using [BenchmarkDotNet](https://github.com/dotnet/BenchmarkDotNet).

Below piece of code presents two methods which are compared in my test.

~~~ csharp
public void Get()
{
    using (var ctx = new AdventureWorks2017Entities())
    {
        var tmp = ctx.TransactionHistories.ToList();
    }
}

public void GetAsNoTracking()
{
    using (var ctx = new AdventureWorks2017Entities())
    {
        var tmp = ctx.TransactionHistories.AsNoTracking().ToList();
    }
}
~~~

The result is pretty good. The arithmetic mean of all measurements with no tracking is 541.4 ms versus  3,601.9 ms with change tracking functionality. Of course, allocated memory per single operation is also smaller in the method without tracking changes respectively 30.92 MB vs 214.12 MB.

If you are interested in the full BenchmarkDotNet report for this test please go to this site: [https://gist.github.com/kmatyaszek/fb7033c1baa546f94c7bcf0d39f14747](https://gist.github.com/kmatyaszek/fb7033c1baa546f94c7bcf0d39f14747)


text:
# BitCask Java

This is an implementation (in progress) of Basho's bitcask; a local
high-performance key/value store which is the preferred backend for
Basho Riak.

I'm doing this in order to

* Understand more of bitcask / riak
* Provide tools to be able to read (write?) bitcask files without using Erlang,
  which could make people more comfortable with using the backend.

bitcask-java tries to e faithful to the original bitcask, so it should be interoperable
and be able to run concurrently with the original.

At this stage, you can create/open a bitcask and get/put data to it. For sample
usage see [BitCaskTest.java](https://github.com/krestenkrab/bitcask-java/blob/master/src/test/java/com/trifork/bitcask/BitCaskTest.java)

Merging is not implemented yet.

You're welcome to help!

Kresten

repository: tenn-cn/bitcask-java

repo_name: tenn-cn/bitcask-java


text:
AI Engine Debug Walkthrough Tutorial - From Simulation to Hardware

AI Engine Debug with Integrated Logic Analyzer (ILA)

[AI Engine Debug with Integrated Logic Analyzer](#AI_Engine_Debug_with_Integrated_Logic_Analyzer)

## AI Engine Debug with Integrated Logic Analyzer (ILA)

Adding ChipScope helps debugging AIE PL interfaces in the design running on hardware including checking for AXI protocol violations, hardware kernel issues, data integrity, and performance issues of the design.
To debug using ILAs, the design is required to enable ILA in hardware build.

## Enable ILA in design

This tutorial uses v++ --debug option to enable ILA IP core insertion to the design.
Syntax:
```
--debug.chipscope <cu_name>[:<interface_name>]
```
Example:
```
v++ -g -l --platform ${PLATFORM} ${XOS} ${LIBADF} \
       --debug.chipscope s2mm_v4_1:s0 \
       --debug.chipscope mm2s_v4_1:s0 \
       -t ${TARGET} ${VPP_FLAGS} -o $@
```
**Note:** v++ allows multiple `--debug.chipscope` lines to meet design debug needs.

### Step 1. Prepare the ILA enabled Makefile.
Use the provided `Makefile.ILA` from this tutorial's root directory. Rename `Makefile.ILA` to `Makefile`.
```bash
cd ${DOWNLOAD_PATH}/AI_Engine_Development/Feature_Tutorials/09-debug-walkthrough
cp Makefile.ILA Makefile
```

### Step 2. Build the ILA enabled design
```bash
make clean; make
```
After the design is built. Inspect the ILA insertion with `mm2s_v4_1:s0` and `s2mm_v4_1:s0` interfaces.
![alt text](images/il_vivado0.png)
![alt text](images/il_vivado1.png)

### Step 3. Boot up the design
Flash the SD card with the ILA enabled design, plug in the flashed SD card to VCK190 sd card slot and boot up the board.

## Setup the connection with Vivado
### Step 4. Setup Connection to the Hardware Board
#### Step 4.1. Target Connection Setup
Run hardware server from computer that connects to target board. To do so, launch hw_server from the computer that has JTAG connection to the VCK190 board.

![alt text](images/hw_ta_hw.png)

#### Step 4.2. Launch Vivado
Launch Vivado™ from where the to be debugged project is by issue command, `vivado`.

#### Step 4.3. Setup Vivado Hardware Manager
After Vivado is up, click on highlighted icon.
![alt text](images/il_open.png)

#### Step 4.4. Setup Hardware Target
![alt text](images/il_open_2.png)

#### Step 4.5. Input Hardware Target
Enter hardware server's IP address or hostname to highlighted area and click **Next**.
![alt text](images/il_open_3.png)

#### Step 4.6. Check Hardware Target
Confirm target's information from JTAG chain then click **Next**.
![alt text](images/il_open_4.png)

#### Step 4.7. Select probe file
Click the ellipsis (**...**) to select the generated probe file, `${PROJECT_PATH}/bf_hw.ltx` or `${PROJECT_PATH}/_x/link/int/bf_hw.ltx` from this design.

![alt text](images/il_pb_file.png)

#### Step 4.8. Select ILA to be examined.
Click on `hw_ila_1` to examine the design.
![alt text](images/il_pb_menu.png)

#### Step 4.9. Setup design's signals to be debugged
Click on `+` to configure the desired signals and their values during run time.
![alt text](images/il_pb_trig.png)

Example below selects TVALID signal from `mm2s_v4_1_s0` and `vitis_design_s2mm_v4_1_0_so` interfaces that capture valid transfers are driven from master. Set value to `B (both transition` so transitions of valid data signals can be captured.

![alt text](images/il_pb_trig1.png)

#### Step 4.10. Enable ILA to capture the configured signals to debug
Click one of highlighted icons to capture configured signals.
![alt text](images/il_trig_run.png)

Wait for ILA is ready to capture signals, run the application from vck190 board.

#### Step 4.11. Expected result
![alt text](images/il_run_done.png)

After completing above steps, we are able to see the captured, related AXI signals and data are shown in waveform with timing information from Vivado.

#### Step 5. Examine captured results
![alt text](images/il_run_result.png)

Expand `slot_0:mm2s_v4_1_s0:Interface` and `slot_1:vitis_design_s2mm_v4_1_0_s0:Interface` by click on `>` icon.
Review the above captured result. `mm2s_v4_1_s0:TVALID` shows '1' which indicates a valid data is available at the time marker pointed.
Moving time marker across time line, changes of AIX protocol values indicate values changed at what time shown below. For example at clock cycle 4, `TVALID` is 1 where `TDATA` is `57f8a5855ea25c52`. This is how to determine when and what a valid data is sent/received.
![alt text](images/il_run_result1.png)

# Support

GitHub issues will be used for tracking requests and bugs. For questions go to [support.xilinx.com](https://support.xilinx.com/).

# License

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.

XD005 | © Copyright 2021-2022 Xilinx, Inc.

repository: tcxxxx/Vitis-Tutorials

repo_name: tcxxxx/Vitis-Tutorials


text:
# sweeper

Exposes the private keys (in WIF) that have been generated by the registrar

* Reads encrypted private keys from database created by registrar
* Decrypts using a user-entered passphrase
* Prints keys in WIF format to stdout, so they can be imported into bitcoind

## DEPENDENCIES/SETUP

* java runtime
* uses AES256 and requires the UnlimitedJCEPolicy be installed
* HSQLDB library must be in /lib directory
* Obtain a copy of the registrar's KeyStore database and place files in cwd

repository: bitsanity/bitshift

repo_name: bitsanity/bitshift