text:
---
tags:
- training
- bash
title: Console Cowboys
date: 2019-10-16T19:59:00Z
ogImage: ''

---
## UNIX is FUBU

One of the reasons that UNIX (and later Linux) are so loved is that they are systems written by programmers, for programmers. The tools in the UNIX tool box are built for automating away all of your mundane tasks and customizing your environment for your own convenience. The shell is the first and most essential tool at your disposal, and the gateway to all of the other power found in the UNIX philosophy. There are several UNIX shells that have been used over the years, but the most popular shell at the moment is bash.

## Bash-ing the competition

Bash is awesome. It's a fully Turing-complete programming language, and has all the things you'd expect from a Real Programming Language like variables, control flows, loops, subroutines, etc. It's designed to be easy to use both interactively (at the command line) and run as a program. Bash is best used for gluing other programs together, which makes it ideal as a systems admin language.

Other operating systems never developed a shell language that was as powerful and as usable as bash. They've just had to join it. Apple gave up on the project entirely; if you open a command line on a Mac, you are face to cursor with bash. Microsoft's batch language was not nearly as feature rich as bash, so they created PowerShell. I don't know if you've ever tried to use PowerShell interactively; but let's just say it isn't its strong suit.

## Learning bash

Because bash is nearly ubiquitous, there are lots of good tutorials, books, and videos for it available online. Here are a couple:

### LearnShell.org

[https://www.learnshell.org/](https://www.learnshell.org/ "https://www.learnshell.org/")

Learn shell is a great site for learning the basics. Each page has a live code example that you complete for each concept you learn – a little bit of hands-on learning goes a long way!

### Bash Academy

[https://guide.bash.academy/](https://guide.bash.academy/ "https://guide.bash.academy/")

Bash academy is more, well… academic in its approach. There's more to learn here and if you want to do a deeper dive, I think this is the place to go next.

repository: adamlindell/Hylia-example

repo_name: adamlindell/Hylia-example


text:
# Examples

Learn **Yao** by examples.

To open the jupyter notebook, please install `IJulia`:

In v0.6, please type

```julia
julia> Pkg.add("IJulia")
```

In v0.7, please type `]` to pkg mode, and use this command

```julia
pkg> add IJulia
```

Then, use IJulia to open notebook service.

```julia
julia> using IJulia

julia> IJulia.notebook()
```

Or just open it from command line

```sh
jupyter-notebook xxxx.ipynb
```

### Quantum Circuit Born Machine

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# Maven Interpolated Variables

This project is an example of a project using interpolated variables.

`pom.xml` at the root directory declares the properties for the coordinates and version of the dependencies to use.

There is only one child module. `pom.xml` in `child-module/` inherits from the root's `pom.xml` and uses the properties defined in the parent `pom` to define dependencies:
- jbcrypt 0.3m by org.mindrot
- apache.sling.engine 2.0.4-incubator by org.apache.sling

The setup of this project results in the following final configuration:
- 2 direct dependencies.
- 14 transitive dependencies.
- 10 vulnerabilities.

#### Vulnerable Call Chain
Main.java has a method call at lines 9-10 that leads to a vulnerability.

#### What's next?
By running the security scanner of your choice against `interpolated-variables` project, you should get results that are coherent with the details above.

repository: codelion/efda

gha_language: C

repo_name: codelion/efda


text:
---
title: Workflow Overview
description: >-
    An overview of each step in Bactopia with a description of the tools used in each step.
---
# Workflow Overview
Bactopia is an extensive workflow integrating numerous steps in bacterial genome analysis. Through out the workflow there are steps that are *always enabled* and *dataset enabled*. Each of the steps depicted in the image below are described in this section.

A list of software **directly** used in each step is also listed. Please check out the [Acknowledgements](acknowledgements/) section to get the full list of software as well how to download and cite said software.

<a class="zoom" href="/assets/bactopia-workflow.png">
![Bactopia Workflow](/assets/bactopia-workflow.png)
</a>

## Always Enabled Steps
The *Always Enabled Steps* are always executed by Bactopia. These steps do not depend of external datasets and thus are always enabled.

#### Gather FASTQs
Specifies exactly where the input FASTQ/FASTAs are coming from. If you are using local inputs (e.g. `--R1/--R2`, `--fastqs`) it will verify they can be accessed.

If an accession(s) (`--accession` or `--accessions`) was given, the corresponding FASTQs (SRA/ENA) or assemblies (NCBI Assembly) are downloaded in this step. All assemblies will have 2x250bp Illumina reads simulated withour insertions or deletions and a minimum PHRED score of Q33.

| Software | Usage   |
|----------|:--------------|
| [ART](https://github.com/rpetit3/ena-dl)   | Generate simulated Illumina reads from an assembly |
| [ena-dl](https://github.com/rpetit3/ena-dl)   | Download FASTQ files from ENA |
| [ncbi-genome-download](https://github.com/rpetit3/ena-dl)   | Download GenBank/RefSeq assemblies from NCBI Assembly database |

#### Validate FASTQs
Determines if the FASTQ file contains enough sequencing to continue processing. The `--min_reads` and `--min_basepairs` parameters adjust the minimum amount of sequencing required to continue processing. This step does not *directly* test the validity of the FASTQ format (although, it would fail if the format is invalid!).

| Software | Usage |
|----------|:--------------|
| [fastq-scan](https://github.com/rpetit3/fastq-scan) | Determine total read and basepairs of FASTQ |

#### Original Summary
Produces summary statistics (read lengths, quality scores, etc...) based on the original input FASTQs.

| Software | Usage |
|----------|:--------------|
| [FastQC](https://github.com/s-andrews/FastQC)   | Generates a HTML report of original FASTQ summary statistics |
| [fastq-scan](https://github.com/rpetit3/fastq-scan) | Generates original FASTQ summary statistics in JSON format |

#### Genome Size
The genome size is by various programs in the Bactopia workflow. By default, if no genome size is given one is estimated using Mash. Otherwise, a specific genome size can be specified or completely disabled using the `--genome_size` parameter. See [Genome Size Parameter](usage-basic/#-genome_size) to learn more about specifying the genome size.

| Software | Usage |
|----------|:--------------|
| [Mash](https://github.com/marbl/Mash)     | If not given, estimates genome size of sample |

#### Quality Control
The input FASTQs go through a few clean up steps. First, Illumina related adapters and phiX contaminants are removed. Then reads that fail to pass length and/or quality requirements are filtered out. If the genome size is available, sequence error-corrections are made and the total sequencing is reduced to a specified coverage. After this step, all downstream analyses are based on the QC'd FASTQ and the original is no longer used.

| Software | Description |
|----------|:--------------|
| [BBTools](https://jgi.doe.gov/data-and-tools/bbtools/)  | Removes Illumina adapters, phiX contaminants, filters reads based on length and quality score, and reduces inputs to a specified coverage. |
| [Lighter](https://github.com/mourisl/Lighter)  | Corrects sequencing errors |

#### QC Summary
Produces summary statistics (read lengths, quality scores, etc...) based on the final set of QC'd FASTQs.

| Software | Usage |
|----------|:--------------|
| [FastQC](https://github.com/s-andrews/FastQC)   | Generates a HTML report of QC'd FASTQ summary statistics |
| [fastq-scan](https://github.com/rpetit3/fastq-scan) | Generates QC'd FASTQ summary statistics in JSON format |

#### Count 31-mers
All 31 basepair (31-mers) sequences are counted and the singletons (those 31-mers only counted once) are filtered out.

| Software | Description |
|----------|:--------------|
| [McCortex](https://github.com/mcveanlab/mccortex) | Counts 31-mers in the input FASTQ |

#### Minmer Sketch
A minmer sketch and signature is created based on the QC'd FASTQs for multiple values of *k*. If datasets are available, the sketches/signatures are used for further downstream analysis.

| Software | Usage   |
|----------|:--------------|
| [Mash](https://github.com/marbl/Mash) | Produces a sketch (*k*=21,31) of tje QC'd FASTQ |
| [Sourmash](https://github.com/dib-lab/sourmash) | Produces a signature (*k*=21,31,51) of the QC'd FASTQ |

#### De novo Assembly
The QC'd FASTQs are assembled using the [Shovill](https://github.com/tseemann/shovill) pipeline. This allows for a seamless assembly process using [MEGAHIT](https://github.com/voutcn/megahit), [SKESA](https://github.com/ncbi/SKESA), [SPAdes](https://github.com/ablab/spades) or [Velvet](https://github.com/dzerbino/velvet). Alternatively, if long reads are available to complement Illumina paired-end reads, hybrid assembly is available through [Unicycler](https://github.com/rrwick/Unicycler).

| Software | Usage   |
|----------|:--------------|
| [assembly-scan](https://github.com/rpetit3/assembly-scan) | Generates summary statistics of the final assembly |
| [Shovill](https://github.com/tseemann/shovill)  | Manages multiple steps in the Illumina assembly process |
| [Unicycler](https://github.com/rrwick/Unicycler) | Manages multiple steps in the hybrid assembly process |

#### Assembly Quality Assessment
After assembly, the *de novo* assembly is assessed for its biological (e.g. containment & contamination) as well as its technical (e.g. misassemblies and errors) quality using [CheckM](https://github.com/Ecogenomics/CheckM) and [QUAST](http://quast.sourceforge.net/).

| Software | Usage   |
|----------|:--------------|
| [CheckM](https://github.com/Ecogenomics/CheckM) | Assess the biological quality of a *de novo* assembly based on presence of marker genes |
| [QUAST](http://quast.sourceforge.net/) | Gives a summary on the technical (e.g. misassemblies etc) quality of a *de novo* assembly |

#### Genome Annotation
Genes are predicted and annotated from the assembled genome using [Prokka](https://github.com/tseemann/prokka). If available, a [clustered RefSeq protein set](datasets/#species-specific) is used for the first pass of annotation.

| Software | Usage   |
|----------|:--------------|
| [Prokka](https://github.com/tseemann/prokka)   | Predicts and annotates assembled genomes |

#### Antimicrobial Resistance
Searches for antimicrobial resistance genes and assosiated point mutations in the annotated gene and protein sequences. If datasets are available, [local assemblies](workflow-overview/#local-assembly) can also be used to predict antibiotic resistance.

| Software | Usage   |
|----------|:--------------|
| [AMRFinderPlus](https://github.com/ncbi/amr) | Predicts antimicrobial resistance based on genes and point mutations |

## Dataset Enabled Steps
The remaining *Dataset Enabled Steps* require supplemental datasets to be available to be executed. There are many datasets available that Bactopia can take advantage of. To learn more about setting up these datasets, check out [Build Datasets](datasets/#build-datasets). These datasets can be broken into two groups, *Public Datasets* and *User Datasets*.

### Public Datasets
[Publicly available datasets](datasets/#general) can be used for further analysis.

#### Call Variants (Auto)
Variants are predicted using [Snippy](https://github.com/tseemann/snippy). The QC'd FASTQs are aligned to the nearest (based on Mash distance) RefSeq completed genome. By default, only the nearest genome is selected, but multiple genomes can be selected (`--max_references`) or this feature can be completely disabled (`disable_auto_variants`).

| Software | Usage   |
|----------|:--------------|
| [Bedtools](https://github.com/arq5x/bedtools2) | Generates the per-base coverage of the reference alignment |
| [NCBI Genome Download](https://github.com/kblin/ncbi-genome-download) | Downloads the RefSeq completed genome |
| [Snippy](https://github.com/tseemann/snippy)   | Manages multiple steps in the haploid variant calling process |
| [vcf-annotator](https://github.com/rpetit3/vcf-annotator) | Adds annotations from reference GenBank to the final VCF |

#### Minmer Query
Screens QC'd FASTQs and signatures against available [Minmer Datasets](acknowledgements/#minmer-datasets).

| Software | Usage   |
|----------|:--------------|
| [Mash](https://github.com/marbl/Mash) | Screens against RefSeq and/or PLSDB sketches |
| [Sourmash](https://github.com/dib-lab/sourmash) | Screens signature against GenBank |

#### Sequence Type
Uses a [PubMLST.org](https://pubmlst.org/) MLST schema to determine the sequence type of the sample.

| Software | Usage   |
|----------|:--------------|
| [Ariba](https://github.com/sanger-pathogens/ariba)    | Runs QC'd FASTQ against a MLST database |
| [BLAST](https://blast.ncbi.nlm.nih.gov/Blast.cgi)   | Aligns MLST loci against the assembled genome |

### User Datasets
Another option is for users to [provide their own data](datasets/#user-populated-folders) to include in the analysis.

#### BLAST Alignment
Each gene, protein, or primer sequence provided by the user is aligned against the assembled genome.

| Software | Usage   |
|----------|:--------------|
| [BLAST](https://blast.ncbi.nlm.nih.gov/Blast.cgi)   | Aligns reference sequences against the assembled genome |

#### Call Variants (User)
Uses the same procedure as [Call Variants (Auto)](workflow-overview/#call-variants-auto), except variants are called against each reference provided by the user.

| Software | Usage   |
|----------|:--------------|
| [Bedtools](https://github.com/arq5x/bedtools2) | Generates the per-base coverage of the reference alignment |
| [Snippy](https://github.com/tseemann/snippy)   | Manages multiple steps in the haploid variant calling process |
| [vcf-annotator](https://github.com/rpetit3/vcf-annotator) | Adds annotations from reference GenBank to the final VCF |

#### Reference Mapping
Aligns the QC'd FASTQs to each sequence provided by the user.

| Software | Usage   |
|----------|:--------------|
| [Bedtools](https://github.com/arq5x/bedtools2) | Generates the per-base coverage of the reference alignment |
| [BWA](https://github.com/lh3/bwa/)      | Aligns QC'd FASTQ to a reference sequence |
| [Samtools](https://github.com/samtools/samtools) | Converts alignment from SAM to BAM |

license: MIT

gha_language: Jinja

gha_license_id: MIT


text:
---
title: Checkbox
category: other-ui
---
## General Design Considerations

Here’s the when and why we use a checkbox (traditional looking checkbox user interface component) in simulation design.

* Generally, when a secondary or non-essential option needs to be toggled between on and off states
* To toggle more than one option in a group of options
* Checkboxes are often used to allow users to layer on more complex representations, or to view multiple, related represenations simultaneously. More complex options are generally off by default.

**Note this design pattern covers multiple PhET Component Types**
* Question: Are there any other types of visual checkboxes?

## Aesthetic Considerations
* Checkbox appears checked or not checked on simulation load
* Appears with a text-based label, or an icon as the label, or a combination of both text and icon
* Title case is used for text-based labels for checkboxes

## Accessibility Considerations
* HTML checkboxes (i.e., `input type="checkbox"`) and possibly all visual PhET sim checkboxes are two-state controls that represent the element's "checkedness" state.
* Traditional looking checkboxes with visual labels are generally best represented in the PDOM as an `input` of type checkbox with an associated `label` element.
* When the visual label content is an image or a string of text that does immediately translate into a name that clearly communicates what the checkbox is for, non-visually, consider changing the visual string, adding clarifying help text, or providing a more descriptive name as the `label` element's content in the PDOM. Keep in mind that ideally, the visual text and the text in the PDOM should be the same to support users who use voiced commands.
* Groups of related checkboxes may benefit from being explicitly grouped using a containing element (e.g., `fieldset` or `div`) with the ARIA `role="group"`. Grouping checkboxes is optional.
* Explicitly grouped checkboxes may benefit from a group name provided by either an `h3` or a `legend`.
* Checkboxes that appear visually grouped (e.g., by proximity or with a visual box) for convenience or space-saving may not benefit from explicit group semantics in the PDOM.
* When a group is very important, consider using a heading, e.g., `h3` as headings are placed in the heading outline which can be navigated with screen reader software whereas the `legend` element is not placed in the heading hierarchy.

**Note:** Known issue that some screen readers (i.e., VoiceOver) repeat the checkbox's label content when the `label` is associated with the `input` via the `for` attribute. We discovered that we do not get repetition of the label content when the `label` comes before the checkbox. When there is no visible screen label, the `aria-label` attribute is an option, and it also does not cause any repetition.

### Gesture Support
ToDO.

### Keyboard Support
| Key | Function |
| :-- | :------- |
|Tab | Moves keyboard focus to the checkbox. |
|Space | Toggles checkbox between checked and unchecked states. |

### Management of Role, Property, State, and Tabindex Attributes
Respecting the first rule of ARIA, "use a native HTML element whenever possible", we use native checkbox elements in the PDOM to represent traditional looking checkbox interactions. An HTML checkbox could represent other "switching" interactions that may not visaully look like a checkbox in the simulation, but examples for those are provided elsewhere. Because we use native HTML for checkbox interactions, some of the guidance provided in ARIA Practices for checkbox widgets is not relevant. I have adapted the content from the ARIA practices section for checkbox.
- No explicit ARIA role of checkbox is needed on an native HTML checkbox (`input type="checkbox"`).
- No `tabindex` required, native HTML checkboxes are focusable elements.
- An HTML checkbox has an accessible label (i.e., accessible name) provided by one of two of the following ways:
  - Visible text content contained within a `label` element and assocaited to its `input` with the `for` attribute.
  - Content within an `aria-label` attribute set on the `input` element with `type="checkbox"`.
- When checked, the checkbox element has the attribute `checked` present.
- When not checked, the `checked` attribute is not present.
- When partially checked, it has state `aria-checked` set to `mixed`. *(tri-state checkboxes only)*
- When a set of checkboxes is presented as a logical group with a visible label, the checkboxes are included in an element with `role="group"` that has the property `aria-labelledby` set to the ID of the element containing the label or name for the group.
- When the presentation includes additional descriptive static text (i.e., help text) relevant to a checkbox or group of checkboxes, using `aria-describedby` is an option to provide automatically read help text. We have, however, that automatic helptext is not needed in our sims. Users seem to prefer on-demand help text.

### Simplified HTML Examples for PDOM
#### Options for Checkbox in the A11y API
When creating the common code component, it would be useful to have options to use either a `label` element or an `aria-label` attribute to provide the accessible name for the checkbox.

#### Checkbox with visual label text
##### Energy Forms and Changes
Visual checkbox with a text-based label:
![alt text "Sample unchecked checkbox for Engery Symbols"](images/efac-checkbox-energy-symbols.png "Energy Symbols, checkbox checked")

###### State Descriptions
```html
<input id=”energy-symbols” type=”checkbox”> <!-- not checked checkbox-->
<label for=”energy-symbols”>Energy Symbols</label>
<p>Observe energy chunks move and change through system.</p>
```
###### Responsive Descriptions
* When checked: Symbols flow with energies.
* When unchecked: Energy symbols hidden.

#### Checkbox without visual label text (option with aria-label)
##### Area Model Introduction
Visual checkbox with different label
![alt text "Sample check"](images/ami-checkbox-123.png "Numeric Checkbox")

```html
<input id="counting-numbers" type="checkbox" aria-label="Counting numbers">
<p>Use area grid with or without counting numbers in grid cells.</p>
```

#### Unnamed group of checkboxes
##### Gravity Force Lab
**Note: still need to finish this example.**

```html
<input id=”” type=”checkbox”> <!-- not checked checkbox-->
<label for=””>Constant Size</label>
<p>When changing mass, observe constant or changing size of spheres.</p>

<input id=”” type=”checkbox”> <!-- not checked checkbox-->
<label for=””>Force Values</label>
<p>Explore value of forces in newtons.</p>

<input id=”” type=”checkbox”> <!-- not checked checkbox-->
<label for=””>Scientific Notation</label>
<p>Listen to newtons in scientific notation.</p>
```

### Supporting Accessibility Resources
* [Using ARIA, working draft](https://www.w3.org/TR/using-aria/)
* [HTML5.1, Section <IP_ADDRESS>.15. Checkbox state](https://www.w3.org/TR/html51/sec-forms.html#checkbox-state-typecheckbox)
* [ARIA Practices 1.1 Section 3.6 Checkbox](https://www.w3.org/TR/wai-aria-practices/)

### Checkbox Snippet for Design Document
**{{checkbox name}}, checkbox**
- Accessible Name:
- Interaction Type: checkbox or non-visual checkbox
- Initial State: checked/ not checked
- (Optional) Help Text:
- (Optional) Context responses or link to section with context responses.
- (Optional) **Design Note:** Special things about this checkbox, if any.

repository: phetsims/sun

gha_language: TypeScript

repo_name: phetsims/sun


text:
---
external help file: Microsoft.Azure.PowerShell.Cmdlets.KeyVault.dll-Help.xml
Module Name: Az.KeyVault
ms.assetid: A7C287C4-E9FD-407A-91BD-EFA17C33FC8B
online version: https://docs.microsoft.com/en-us/powershell/module/az.keyvault/get-azkeyvault
schema: 2.0.0
---

# Get-AzKeyVault

## SYNOPSIS
Gets key vaults.

## SYNTAX

### GetVaultByName (Default)
```
Get-AzKeyVault [[-VaultName] <String>] [[-ResourceGroupName] <String>] [-Tag <Hashtable>]
 [-DefaultProfile <IAzureContextContainer>] [<CommonParameters>]
```

### ByDeletedVault
```
Get-AzKeyVault [-VaultName] <String> [-Location] <String> [-InRemovedState]
 [-DefaultProfile <IAzureContextContainer>] [<CommonParameters>]
```

### ListAllDeletedVaultsInSubscription
```
Get-AzKeyVault [-InRemovedState] [-DefaultProfile <IAzureContextContainer>] [<CommonParameters>]
```

## DESCRIPTION
The **Get-AzKeyVault** cmdlet gets information about the key vaults in a subscription. You can
view all key vaults instances in a subscription, or filter your results by a resource group or a
particular key vault.
Note that although specifying the resource group is optional for this cmdlet when you get a single
key vault, you should do so for better performance.

## EXAMPLES

### Example 1: Get all key vaults in your current subscription
```powershell
PS C:\> Get-AzKeyVault

Vault Name          : myvault1
Resource Group Name : myrg
Location            : westus
Resource ID         : /subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxxx/resourceGroups/myrg/providers/Microsoft.Ke
                      yVault/vaults/myvault1
Tags                :

Vault Name          : myvault2
Resource Group Name : myrg1
Location            : westus
Resource ID         : /subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxxx/resourceGroups/myrg1/providers/Microsoft.Ke
                      yVault/vaults/myvault2
Tags                :

Vault Name          : myvault3
Resource Group Name : myrg1
Location            : westus
Resource ID         : /subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxxx/resourceGroups/myrg1/providers/Microsoft.Ke
                      yVault/vaults/myvault3
Tags                :
```

This command gets all the key vaults in your current subscription.

### Example 2: Get a specific key vault
```powershell
PS C:\> Get-AzKeyVault -VaultName 'myvault'

Vault Name                       : myvault
Resource Group Name              : myrg
Location                         : westus
Resource ID                      : /subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxxx/resourceGroups/myrg/providers
                                   /Microsoft.KeyVault/vaults/myvault
Vault URI                        : https://myvault.vault.azure.net/
Tenant ID                        : xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxxx
SKU                              : Standard
Enabled For Deployment?          : True
Enabled For Template Deployment? : True
Enabled For Disk Encryption?     : False
Soft Delete Enabled?             : True
Access Policies                  :
                                   Tenant ID                                  : xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxxx
                                   Object ID                                  : xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxxx
                                   Application ID                             :
                                   Display Name                               : User Name<EMAIL_ADDRESS>                                   Permissions to Keys                        : get, create, delete, list, update,
                                   import, backup, restore, recover
                                   Permissions to Secrets                     : get, list, set, delete, backup,
                                   restore, recover
                                   Permissions to Certificates                : get, delete, list, create, import,
                                   update, deleteissuers, getissuers, listissuers, managecontacts, manageissuers,
                                   setissuers, recover
                                   Permissions to (Key Vault Managed) Storage : delete, deletesas, get, getsas, list,
                                   listsas, regeneratekey, set, setsas, update

Tags                             :
```

This command gets the key vault named myvault in your current subscription.

### Example 3: Get key vaults in a resource group
```powershell
PS C:\> Get-AzKeyVault -ResourceGroupName 'myrg1'

Vault Name          : myvault2
Resource Group Name : myrg1
Location            : westus
Resource ID         : /subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxxx/resourceGroups/myrg1/providers/Microsoft.Ke
                      yVault/vaults/myvault2
Tags                :

Vault Name          : myvault3
Resource Group Name : myrg1
Location            : westus
Resource ID         : /subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxxx/resourceGroups/myrg1/providers/Microsoft.Ke
                      yVault/vaults/myvault3
Tags                :
```

This command gets all the key vaults in the resource group named ContosoPayRollResourceGroup.

### Example 4: Get all deleted key vaults in your current subscription
```powershell
PS C:\> Get-AzKeyVault -InRemovedState

Vault Name           : myvault4
Location             : westus
Id                   : /subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxxx/providers/Microsoft.KeyVault/locations/westu
                       s/deletedVaults/myvault4
Resource ID          : /subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxxx/resourceGroups/myrg/providers/Microsoft.K
                       eyVault/vaults/myvault4
Deletion Date        : 5/24/2018 9:33:24 PM
Scheduled Purge Date : 8/22/2018 9:33:24 PM
Tags                 :
```

This command gets all the deleted key vaults in your current subscription.

### Example 5: Get a deleted key vault
```powershell
PS C:\> Get-AzKeyVault -VaultName 'myvault4'  -Location 'westus' -InRemovedState

Vault Name           : myvault4
Location             : westus
Id                   : /subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxxx/providers/Microsoft.KeyVault/locations/westu
                       s/deletedVaults/myvault4
Resource ID          : /subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxxx/resourceGroups/myrg/providers/Microsoft.K
                       eyVault/vaults/myvault4
Deletion Date        : 5/24/2018 9:33:24 PM
Scheduled Purge Date : 8/22/2018 9:33:24 PM
Tags                 :
```

This command gets the deleted key vault information named myvault4 in your current
subscription and in westus region.

### Example 6: Get key vaults using filtering
```powershell
PS C:\> Get-AzKeyVault -VaultName 'myvault*'

Vault Name          : myvault2
Resource Group Name : myrg1
Location            : westus
Resource ID         : /subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxxx/resourceGroups/myrg1/providers/Microsoft.Ke
                      yVault/vaults/myvault2
Tags                :

Vault Name          : myvault3
Resource Group Name : myrg1
Location            : westus
Resource ID         : /subscriptions/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxxx/resourceGroups/myrg1/providers/Microsoft.Ke
                      yVault/vaults/myvault3
Tags                :
```

This command gets all the key vaults in the subscription that start with "myvault".

## PARAMETERS

### -DefaultProfile
The credentials, account, tenant, and subscription used for communication with azure

```yaml
Type: Microsoft.Azure.Commands.Common.Authentication.Abstractions.Core.IAzureContextContainer
Parameter Sets: (All)
Aliases: AzContext, AzureRmContext, AzureCredential

Required: False
Position: Named
Default value: None
Accept pipeline input: False
Accept wildcard characters: False
```

### -InRemovedState
Specifies whether to show the previously deleted vaults in the output.

```yaml
Type: System.Management.Automation.SwitchParameter
Parameter Sets: ByDeletedVault, ListAllDeletedVaultsInSubscription
Aliases:

Required: True
Position: Named
Default value: None
Accept pipeline input: False
Accept wildcard characters: False
```

### -Location
The location of the deleted vault.

```yaml
Type: System.String
Parameter Sets: ByDeletedVault
Aliases:

Required: True
Position: 1
Default value: None
Accept pipeline input: True (ByPropertyName)
Accept wildcard characters: False
```

### -ResourceGroupName
Specifies the name of the resource group associated with the key vault or key vaults being queried.

```yaml
Type: System.String
Parameter Sets: GetVaultByName
Aliases:

Required: False
Position: 1
Default value: None
Accept pipeline input: True (ByPropertyName)
Accept wildcard characters: True
```

### -Tag
Key-value pairs in the form of a hash table. For example:
@{key0="value0";key1=$null;key2="value2"}

```yaml
Type: System.Collections.Hashtable
Parameter Sets: GetVaultByName
Aliases:

Required: False
Position: Named
Default value: None
Accept pipeline input: True (ByPropertyName)
Accept wildcard characters: False
```

### -VaultName
Specifies the name of the key vault.

```yaml
Type: System.String
Parameter Sets: GetVaultByName
Aliases: Name

Required: False
Position: 0
Default value: None
Accept pipeline input: True (ByPropertyName)
Accept wildcard characters: True
```

```yaml
Type: System.String
Parameter Sets: ByDeletedVault
Aliases: Name

Required: True
Position: 0
Default value: None
Accept pipeline input: True (ByPropertyName)
Accept wildcard characters: True
```

### CommonParameters
This cmdlet supports the common parameters: -Debug, -ErrorAction, -ErrorVariable, -InformationAction, -InformationVariable, -OutVariable, -OutBuffer, -PipelineVariable, -Verbose, -WarningAction, and -WarningVariable. For more information, see [about_CommonParameters](http://go.microsoft.com/fwlink/?LinkID=113216).

## INPUTS

### System.String

### System.Collections.Hashtable

## OUTPUTS

### Microsoft.Azure.Commands.KeyVault.Models.PSKeyVault

### Microsoft.Azure.Commands.KeyVault.Models.PSKeyVaultIdentityItem

### Microsoft.Azure.Commands.KeyVault.Models.PSDeletedKeyVault

## NOTES

## RELATED LINKS

[New-AzKeyVault](./New-AzKeyVault.md)

[Remove-AzKeyVault](./Remove-AzKeyVault.md)

repository: wastoresh/azure-powershell

gha_language: C#

gha_license_id: NOASSERTION

repo_name: wastoresh/azure-powershell


text:
# Change Log

All notable changes to this project will be documented in this file.
See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.

## [12.1.6](https://github.com/egoist/poi/compare/@poi/dev-utils@12.1.5<EMAIL_ADDRESS>(2020-08-19)

### Bug Fixes

- make react-refresh work better with error overlay ([e6deed4](https://github.com/egoist/poi/commit/e6deed4))

## [12.1.5](https://github.com/egoist/poi/compare/@poi/dev-utils@12.1.4<EMAIL_ADDRESS>(2020-07-13)

**Note:** Version bump only for package @poi/dev-utils

## [12.1.4](https://github.com/egoist/poi/compare/@poi/dev-utils@12.1.3<EMAIL_ADDRESS>(2020-04-30)

**Note:** Version bump only for package @poi/dev-utils

## [12.1.3](https://github.com/egoist/poi/compare/@poi/dev-utils@12.1.2<EMAIL_ADDRESS>(2019-08-09)

### Bug Fixes

- keep the trailing slash of `output.publicUrl` ([#612](https://github.com/egoist/poi/issues/612)) ([56bd612](https://github.com/egoist/poi/commit/56bd612))

## [12.1.2](https://github.com/egoist/poi/compare/@poi/dev-utils@12.1.1<EMAIL_ADDRESS>(2019-07-27)

### Bug Fixes

- Append `poi -s` output URLs with `output.publicUrl` ([#587](https://github.com/egoist/poi/issues/587)) ([fcd70f7](https://github.com/egoist/poi/commit/fcd70f7))

### Features

- enable https one the preview URLs ([#611](https://github.com/egoist/poi/issues/611)) ([cda0ec2](https://github.com/egoist/poi/commit/cda0ec2))

## [12.1.1](https://github.com/egoist/poi/compare/@poi/dev-utils@12.1.0<EMAIL_ADDRESS>(2019-01-23)

### Bug Fixes

- format build time in human-readable format ([a89ecd0](https://github.com/egoist/poi/commit/a89ecd0))
- use a new port if the port is already used ([62053e5](https://github.com/egoist/poi/commit/62053e5))

# [12.1.0](https://github.com/egoist/poi/compare/@poi/dev-utils@12.0.3<EMAIL_ADDRESS>(2019-01-09)

### Bug Fixes

- **dev-utils:** refactor hotDevClient to ES5 compat ([#522](https://github.com/egoist/poi/issues/522)) ([480bce5](https://github.com/egoist/poi/commit/480bce5)), closes [#515](https://github.com/egoist/poi/issues/515)

### Features

- show memory usage ([75f1376](https://github.com/egoist/poi/commit/75f1376))

## [12.0.3](https://github.com/egoist/poi/compare/@poi/dev-utils@12.0.2<EMAIL_ADDRESS>(2018-12-21)

### Bug Fixes

- **cli:** only open browser on the first successful build ([13b1ac8](https://github.com/egoist/poi/commit/13b1ac8))

repository: egoist/poi

gha_language: JavaScript

repo_name: egoist/poi


text:
#### Scripts
##### New: SetPhishingCampaignDetails
- Copying EmailCampaign context from current incident to other existing incident.
This script runs with elevated permissions.
Cortex XSOAR recommends using the built-in RBAC functionality to limit access to only those users requiring access to this script. (Available from Cortex XSOAR 6.0.0).

repository: demisto/content

gha_language: Python

repo_name: demisto/content


text:
# android-dialog

[![Release](https://jitpack.io/v/seven332/android-dialog.svg)](https://jitpack.io/#seven332/android-dialog)

Android-Dialog provides `DialogView` which could be used to build something like dialog.

## Usage

```
repositories {
    maven { url 'https://jitpack.io' }
}

compile 'com.github.seven332.android-dialog:base:{version}'
```

### DialogViewBuilder

That's the builder to build a `DialogView`. It's based on `v7 appcompat library`.

```java
DialogView dialogView = new DialogViewBuilder()
    .title("This is TITLE")
    .message("This is MESSAGE")
    .positiveButton("positive", null)
    .build(inflater, container);
```

DialogView consists of three parts, header, content and footer. `DialogViewBuilder.title()` is header. `DialogViewBuilder.message()` is content. `DialogViewBuilder.positiveButton()` is footer. Custom header/content/footer is supported. Custom content could implement `DialogContent` which is notified about header and footer states.

### DialogView

`DialogView.setDialog()` should be called after being created or some callback may not work fine.

DialogView can get some preset widgets, but they are null if they were not set in `DialogViewBuilder`.

## Add-ons

### conductor

```
repositories {
    maven { url 'https://jitpack.io' }
}

compile 'com.github.seven332.android-dialog:conductor:{version}'
```

`AnDialogController` is a [`DialogController`](https://github.com/seven332/conductor-dialog) which uses `DialogView` as content and uses `v7 appcompat library`'s `R.attr.alertDialogTheme` as default theme.

```java
public class CustomDialog extends AnDialogController {
  @Override
  protected DialogView onCreateDialogView(LayoutInflater inflater, ViewGroup container) {
    return new DialogViewBuilder()
        .title("This is TITLE")
        .message("This is MESSAGE")
        .positiveButton("positive", null)
        .build(inflater, container);
  }
}
```

## License

```
Copyright 2017 Hippo Seven

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

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

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
```


text:
#Navigating our mental health region
App description: In 2012, the mental health and disability system in Iowa was divided into 15 regions across the state. Here's our guide to navigating the mental health region that includes the Cedar Valley.

## Commands
To create your project:

	grunt app

To run a test server:

	grunt server

To get your project ready for deployment:

	grunt public

To deploy via SFTP:

	grunt deploy

## License

[MIT License](http://en.wikipedia.org/wiki/MIT_License)


text:
# NSObject Bindings Additions

These methods on NSObject simplify KVO coding.

## Usage

You can see the sample project in the _Demo_ folder.

**WARNING:** Make sure to remove all the bindings on any object before releasing it. This implementation retains all the objects being observed, as well as the ones being notified of changes.

### Key path bindings

#### bindKeyPath:toObject:withKeyPath:options:

The `options` parameter is not used, just set it to `nil`. Support will be added later.
Returns a unique identifier that can be used to remove the binding.

Creates a binding that updates the `text` property on `label` every time the property `title` of `blogPost` changes.

	[label bindKeyPath:@"text" toObject:blogPost withKeyPath:@"title" options:nil];

### Block-based bindings

#### bindBlock:toObject:withKeyPath:options:

The `options` parameter is not used, just set it to `nil`. Support will be added later.
Returns a unique identifier that can be used to remove the binding.

Executes the block every time the property `title` of `blogPost` changes. The value is the only parameter sent to the block.

	[NSObject bindBlock:^(id value) {
		NSLog(@"Value: %@", value);
	} toObject:blogPost withKeyPath:@"title" options:nil];

_Note: This can be useful to log and debug values._

### Notification bindings

#### bindBlock:toNotification:options:

The `options` parameter is not used, just set it to `nil`. Support will be added later.
Returns a unique identifier that can be used to remove the binding.

Executes the block every time the notification is posted.

**Warning:** Make sure you keep the binding's identifier returned by the method so that you can remove the binding later.

	notificationBindingIdentifier = [NSObject bindBlock:^(id notification) {
		NSLog(@"App did become active");
	} toNotification:UIApplicationDidBecomeActiveNotification options:nil];

### Removing bindings

#### unbindKeyPath:

Removes all the bindings on the `text` property of `label`.

	[label unbindKeyPath:@"text"];

#### unbind

Removes all the bindings on `blogPost`.

	[blogPost unbind];

#### unbindBindingWithUUID:

Removes the binding with a unique identifier

	[NSObject unbindBindingWithUUID:notificationBindingIdentifier];

#### unbindBindingsWithIdentifier:

Removes all the bindings that have `@"MyIdentifier"` as the value for the `OCBindingIdentifierOptionKey` option key. See **Options** for more information.

	[NSObject unbindBindingsWithIdentifier:@"MyIdentifier"];

## Options

When creating a binding you can use the following keys to set options in the `options` dictionary.

### OCBindingIdentifierOptionKey

A NSString that you can use to remove bindings with `unbindBindingsWithIdentifier:`.

## Important

The code is taking advantage of Automatic Reference Counting (ARC). If your project does not use ARC, you will need to update the code. If you do so, please do it nicely, fork the project and send a pull request.

repository: ibright/NSObject-Bindings

repo_name: ibright/NSObject-Bindings


text:
# ForbiddenPublicDataClass

Data classes are bad for binary compatibility in public APIs. Avoid using them.

This rule is aimed at library maintainers. If you are developing a final application you can ignore this issue.

More info: https://jakewharton.com/public-api-challenges-in-kotlin/

## Noncompliant Code

```kotlin
data class C(val a: String) // violation: public data class
```
## Compliant Code

```kotlin
internal data class C(val a: String)
```

[Source](https://arturbosch.github.io/detekt/style.html#forbiddenpublicdataclass)

repository: codacy/codacy-detekt

gha_language: Scala

repo_name: codacy/codacy-detekt


text:
![MIT LICENSE](https://img.shields.io/github/license/scottbromander/the_marketplace.svg?style=flat-square)
![REPO SIZE](https://img.shields.io/github/repo-size/scottbromander/the_marketplace.svg?style=flat-square)
![TOP_LANGUAGE](https://img.shields.io/github/languages/top/scottbromander/the_marketplace.svg?style=flat-square)

# PROJECT NAME

## Description

_Weekend Project_

This web app displays a list of movies, their posters, and a brief description.

The information about the movies is stored in an SQL database.

### Prerequisites

Link to software that is required to install the app (e.g. node).

- [Node.js](https://nodejs.org/en/)
- JavaScript-capable web browser

## Installation

1. Create a database named `saga_movies_weekend`,
2. The queries in the `tables.sql` file are set up to create all the necessary tables and populate the needed data to allow the application to run correctly. The project is built on [Postgres](https://www.postgresql.org/download/), so you will need to make sure to have that installed. We recommend using Postico to run those queries as that was used to create the queries
3. Open up your editor of choice and run an `npm install`
4. Run `npm run server` in your terminal
5. Run `npm run client` in your terminal
6. The `npm run client` command will open up a new browser tab for you!

## Usage

How does someone use this application?

1. Click on a movie to see its page
2. On the movie's page, you can read a brief description
3. If you would like to edit the title or description you can do so by clicking the 'Edit' button
4. Edits can be cancelled with the 'Cancel' button
5. Click 'Home' at the top of the screen at any time to return to the movie list

## Built With

Node
React
Redux
Redux-saga
Axios
Express
pg

## Acknowledgement

Thanks to [Prime Digital Academy](www.primeacademy.io) who equipped and helped me to make this application a reality.

Thank you to my friends in the Paxos cohort for their help.

## Support

If you have suggestions or issues, please contact me at https://github.com/ericelvendahl

repository: ericelvendahl/movie-sagas

repo_name: ericelvendahl/movie-sagas


text:
---
title: "Forest Seed Basket
for present and future understanding,
Black Ash"
info: "life size, 2019 (handwoven black ash, wood)"
credit: "Courtesy the artist and Accola Griefen Fine Art. Image courtesy of Patel Brown Gallery"
---

Image description: A life-sized oxygen tank on its wheeled cylinder cart, with the tank, regulator, tubing, and mask all composed of handwoven black ash splints. The cart handle is crafted from wooden dowels and black ash splints. The body of the oxygen tank is pale with
reddish stripes circling it, made of darker splints. This basket holds seed cones for Sitka spruce trees, Indigenous to the Pacific coast of North America. The tank is positioned on a pale floor near a stark white wall.

repository: naobot/merritt

branch_name: refs/heads/main

repo_name: naobot/merritt


text:
Welcome to Floating-Point WordPress Classess 👋

> Utilies for working with WordPress

## Install

Add the following to your `componser.json`

```json
{
  "require": {
    "floatingpoint/wp-classes": "^1.0"
  },
  "repositories": [
    {
      "type": "composer",
      "url": "https://packages.fpbeta.com/php/"
    }
  ]
}
```

Then run

```sh
composer update
```

## Author

👤 **Floating-Point**

- Twitter: [@floatingpointco](https://twitter.com/floatingpointco)

## Show your support

Give a ⭐ if this project helped you!

## 📝 License

This project is [MIT](https://gitlab.com/floatingpoint/wp-classes/blob/master/LICENSE.md) licensed.

---

_This README was generated with ❤ by [readme-md-generator](https://github.com/kefranabg/readme-md-generator)_

repository: Gabe-Boisvert-Code/wp-classes

repo_name: Gabe-Boisvert-Code/wp-classes


text:
# Typescript notes

## General notes

- NOTE: when the code gets minified, internal property names are probably going to get changed which will mess with type checking.
  - to mitigate this do the below:
      ```ts
      // BAD, WILL BREAK ON DEPLOY
      const isTypedObj = <T extends object, P extends keyof T>(ele: T, prop: P): ele is T => {
        obj != null && prop in obj
      }
      console.log(isTypedObj(blah, 'type') && ele.type.name === 'Name'); // BAD ele.type.name will change on minification;

      // BETTER
      const isTypedObj = () => {} // Same implementation as the above
      const isSpecificEle = (ele: ReactElement<any, any>): boolean => {
        const SpecificEleName: string = SpecificEle.type.name; // GOOD have a reference to the actual Element name or property
        return isTypedObj(ele, 'type') && ele.type.name === SpecificEleName
      }

      // GREAT/ is more reusable
      const isTypedObj = () => {} // Same as the above
      const isReactEle = (ele: ReactElement<any>, eleToMatchWith: ReactElement<any>): ele is eleToMatchWith => {
        const nameToMatch: string = eleToMatchWith.type.name;
        return isTypedObj(ele, 'type') && ele.type.name === nameToMatch;
      }
    ```
    - as a general explanation, the function:
        ```ts
          function <T extends object, P extends keyofT>isTypedObj(obj: T, key: P)
        ```
      checks to make sure that the input `key` exists as a key of the input object `ele`
  - this works because you are:
    a.) extending a fairly basic function already so you're not repeating yourself
    b.) have a specific variable reference to the desired property that won't get lost on minification

## Declaration files

- Declaration files let you make and share commonly used stuff which is nice
- Local declaration files can be specified in `tsconfig.json` with the "typeRoots" option
  - e.g for this project:
  ```json
  {
    "typeRoots": [
        "./node_modules/@types",
        "./src/@types"
      ],
  }
  ```
- For this project as we want to be able to call our custom types anywhere without imports, we add it as a namespace so that it can be accessed globally
- However, we also add it as a module export so you can manually import it into files

## Types Versus Interfaces

- **NOTE** The [TypeScript Handbook](https://www.typescriptlang.org/docs/handbook/advanced-types.html) section on type aliases versus interfaces is not actually up to date as of March 02, 2019
- First let's correct what the docs are saying:
  1. “One difference is, that interfaces create a new name that is used everywhere. Type aliases don’t create a new name — for instance, error messages won’t use the alias name.”
    - this is wrong, errors for type aliases will use the type name in the error message
  2. “A second more important difference is that type aliases cannot be extended or implemented from”
    - also incorrect, you can do that but aaaa

- TL;DR of the important points:
  - you cannot implement a type alias that has a union type inside!
    ```ts
      type RectangleShape = ( Shape | Perimeter ) & Point; // where Shape, Perimeter, and Point are a class, type, and interface
      class Rectangle implements RectangleShape {} // This will throw an exception
    ```
  - interfaces allow declaration merges while type aliases don't
    - i.e
      ```ts
        interface obj {
          foo: string
        }
        interface obj {
          bar: string
        }
      ```
    compiles to:
      ```ts
        interface obj {
          foo: string
          bar: string
        }
    ```
- So for React Components, it's more prudent to have the Props be a type alias rather than an interface
- References below:
  - [Medium article](https://medium.com/@martin_hotell/interface-vs-type-alias-in-typescript-2-7-2a8f1777af4c)

## Decorators

- Aspect Oriented Programming/ separation of cross-cutting concerns


text:
---
title: Nevada County, CA
permalink: "/nevada-county"
name: Letter to County DA, District Supervisors, and City Officials
city: Nevada County
state: CA
layout: email
recipients:
-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>-<EMAIL_ADDRESS>body: |-
  To Whom It May Concern:

  My name is [YOUR NAME], and I am a resident of Nevada County. This past week, our nation has been gripped by protests calling for rapid and meaningful change with regard to police behavior, an end to racism and anti-Blackness, and immediate reform in how Black people are treated in America. Accordingly, it has come to my attention that the budget for 2021 is being decided as these protests continue.

  The three police departments in Nevada County have been a waste of our resources. For the Fiscal Year 2019-2020 in Grass Valley alone, the General Fund Expenditures was $13,093,905. The final budget for the GVPD was $4,141,770. This is a total of 31.6% of the General Fund. Nevada City PD budgeted 45.3% of the General Fund Expenditures ($2,096,760 out of the $4,632,239 Nevada City General Fund). The Truckee Police Department was allocated $6,629,802 out of $23,177,108 in the General Fund.

  While we’ve been spending extraordinary amounts on policing, we have not seen improvements to safety, homelessness, mental health, or affordability in our city. Instead, we see wasteful and harmful actions of our police.

  I call on you to slash the budgets of Nevada County Police Departments and advocate for a meaningful reallocation of the city's expenditures: away from policing, and towards social programs and resources that support services for the homeless, affordable housing, education, health care, child care, and other critical community needs.

  We can be a beacon for other cities to follow if only we have the courage to change.

  Sincerely,

  [YOUR NAME]
  [YOUR ADDRESS]
  [YOUR EMAIL]
  [YOUR PHONE NUMBER]
---


text:
# MediaFilterKit
A swift library for wrapping and applying core image filters to a image or audiovisual asset.

**Installing with cocoapods**
```
pod 'MediaFilterKit'
```

**Quick start**
Start by importing the library into your file
```
import MediaFilterKit
```

You can create a `MFKImage` object and asynchronously apply filters.
```
let image = MFKImage(uiImage: UIImage(named: "image")!)
image.applying(filters: [.chrome]) { self.imageView.image = $0 }
```

You can create an `MFKAsset` object, this object allows you access to the asset's placeholder image (which is a screenshot of the first frame in the video).
```
let mkAsset = MFKAsset(url: URL(string: "https://file-examples-com.github.io/uploads/2017/04/file_example_MP4_480_1_5MG.mp4"))
imageView.image = asset.placeholder
```
OR
```
let asset = AVAsset(url: URL(string: "https://file-examples-com.github.io/uploads/2017/04/file_example_MP4_480_1_5MG.mp4"))
let mkAsset = MFKAsset(asset: asset)
imageView.image = mkAsset.placeholder
```

You can also asynchronously apply filters to an `MFKAsset`.
```
let player: AVPlayer?
mkAsset.applying(filters: [.chrome], with: .presetHighestQuality {
    player = AVPlayer(playerItem: AVPlayerItem(asset: asset))
    player.play()
}
```

repository: appoly/MediaFilterKit

repo_name: appoly/MediaFilterKit


text:
# LINE Icon Switch API sample

LINE new API - [Icon Switch](https://developers.line.biz/zh-hant/reference/messaging-api/#icon-nickname-switch): this API can change icon and display name in same **LINE BOT**

# Trigger text
This bot will catch trigger text to change name and avatar !!🎉
- Sally
- Brown
- Cony

![](https://i.imgur.com/TbtdNFjl.png)

# Developer Side

## LINE account

- Got A LINE Bot API devloper account
Make sure you already registered, if you need use LINE Bot.

 Here is some info you will need to know.
        - Callback URL: `https://{NGROK_URL}/webhooks/line`
        - Verify your webhook.
- You will get following info, need fill back to `.env` file.
    - Channel Secret
    - Channel Access Token (You need to issue one here)

## Normal testing

1. first terminal window
```
cp .env.sample .env
pip install -r requirements.txt --user
python api.py
```

> [2020/03/28] LINE just not already release tag in SDK, so I use git method to install NEW feature package(icon switch).
2. Create a provisional Https:

```
ngrok http 5000
```

or maybe you have npm enviroment:

```
npx ngrok http 5000
```
![](https://i.imgur.com/azVdG8j.png)

3. Copy url to LINE Developer Console

## If you have AWS account
1. Install serverless via npm:

```bash=
$ npm install -g serverless
```

2. Setup your **AWS** ceritficate

```bash=
export AWS_ACCESS_KEY_ID=<your-key-here>
export AWS_SECRET_ACCESS_KEY=<your-secret-key-here>
```

3. Deploy the example:

```bash=
npm install
pip install -r requirements.txt --user
serverless wsgi serve # local testing
serverless deploy     # deploy to AWS
```

4. If deploy, copy the url to LINE Developer Console
# License

MIT License


text:
# AutoLayoutKit

[![Version](https://cocoapod-badges.herokuapp.com/v/AutoLayoutKit/badge.png)](http://cocoadocs.org/docsets/AutoLayoutKit)
[![Platform](https://cocoapod-badges.herokuapp.com/p/AutoLayoutKit/badge.png)](http://cocoadocs.org/docsets/AutoLayoutKit)
[![Build Status](https://travis-ci.org/floriankrueger/AutoLayoutKit.png?branch=master)](https://travis-ci.org/floriankrueger/AutoLayoutKit)
[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/floriankrueger/autolayoutkit/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

## Announcement: Manuscript

You think about using AutoLayoutKit in one of your shiny new swift-only Apps? Well, now you can.

Introducing [Manuscript](https://github.com/floriankrueger/Manuscript), the fancy successor of AutoLayoutKit written in pure Swift. (Carthage compatible, still under development)

## Usage

For a very basic running example check out the example app. Clone the repo and run `pod install` from the Project directory first.

Let me give you a quick example on how easy it is to create NSLayoutConstraints in code using ALK.

```Objective-C
[ALKConstraints layout:childView do:^(ALKConstraints *c) {
  [c make:ALKCenterX equalTo:self s:ALKCenterX];
  [c make:ALKCenterY equalTo:self s:ALKCenterY];
  [c set:ALKWidth to:30.f];
  [c set:ALKHeight to:30.f];
}];
```

Curious what the same code looks without ALK? Check out [this](https://github.com/floriankrueger/AutoLayoutKit/wiki/Without-AutoLayoutKit).

### New in Version 0.6.0: Convenience Methods

Entering Version 0.6.0, the basic sample from above can be improved even further.

```Objective-C
[ALKConstraints layout:childView do:^(ALKConstraints *c) {
  [c centerIn:self];
  [c setSize:CGSizeMake(30.f, 30.f)];
}];
```

### New in Version 1.0.0:
#### Using with Swift without optional chaining
```Swift
ALKConstraints.layout(titleLabel) { c in
  c.make(.trailing, equalTo: self, s: .trailing, minus: 10)
}
```

#### Store newly created active constraint to block valiable
```Objective-C
__block NSLayoutConstraint * heightConstraint = nil;
[ALKConstraints layout:self.view do:^(ALKConstraints * c) {
  heightConstraint = [c set:ALKHeight to:100.f];
}];
```
```Swift
var leadingConstraint: NSLayoutConstraint? = nil
ALKConstraints.layout(titleLabel) { c in
  leadingConstraint = c.make(.leading, equalTo: self, s: .leading, plus: 10)
}
```

#### Using iOS 11 [Safe Area](https://developer.apple.com/documentation/uikit/uiview/positioning_content_relative_to_the_safe_area)

> In case of iOS version less than 11, default `make...` methods will be used as fallback.

> All [Safe Area](https://developer.apple.com/documentation/uikit/uiview/positioning_content_relative_to_the_safe_area) methods uses times value as 1.0.

```Objective-C
[ALKConstraints layout:titleLabel do:^(ALKConstraints * c) {
  [c make:ALKLeading equalToSafeArea:self.view s:ALKLeading plus:8];
  [c make:ALKTrailing equalToSafeArea:self.view s:ALKTrailing minus:8];
}];
```
```Swift
ALKConstraints.layout(titleLabel) { c in
  c.make(.leading, equalToSafeArea: self, s: .leading, plus: 8)
  c.make(.trailing, equalToSafeArea: self, s: .trailing, minus: 8)
}
```

## Requirements

## Installation

*AutoLayoutKit* is available through [CocoaPods](http://cocoapods.org), to install
it simply add the following line to your Podfile:

```Ruby
pod "AutoLayoutKit"
```

## Author

Florian Krueger<EMAIL_ADDRESS>
## License

*AutoLayoutKit* is available under the MIT license. See the LICENSE file for more info.

repository: AutoLayoutKit/AutoLayoutKit

repo_name: AutoLayoutKit/AutoLayoutKit


text:
#SockBot Math

Math plugin for [SockBot](https://sockbot.rtfd.org/en/latest/) version 2.0.0 or later; uses the [MathJS](http://mathjs.org/docs/) library to evaluate mathematical expressions.

##Usage

SockBot Math registers the command `!math`, which takes a mathematical expression as its sole argument, and can either be part of a summons, a reply, or a private message.

Command syntax: `!math [expression]`

Example: `!math sqrt(square(3) + square(4))`

##Developers

SockBot Math is developed by [SockDrawer](https://github.com/SockDrawer) developer [RaceProUK](https://github.com/RaceProUK).

##Quickstart Guide

* Create a folder to install to
* Run `npm install sockbot`
* Run `npm install sockbot-math`
* Create a configuration file called `Config.yml` in that folder with the following contents:
```
---
core:
  username: [the bot's username]
  password: [the bot's password]
  owner: [your username]
plugins:
  sockbot-math: true
```
* Run `sockbot Config.yml`

repository: SockDrawer/SockBot-Math

repo_name: SockDrawer/SockBot-Math


text:
# transfer-app

Building Money Transfer Application
-------------------------------
Following command should be used from ‘test’ directory:
`mvn clean package`

Starting Transfer Application
-----------------------------
Following command should be used from ‘test/transfer-app’ directory:
`java -jar target/transfer-app-0.0.1-SNAPSHOT.jar server transfer-app.yml`

Inspecting Database While Application Is Running
------------------------------------------------
Following command should be used from ‘test/transfer-app’ directory:
`java -cp h2-1.4.199.jar org.h2.tools.Server`

This command will start a process able to communicate with in-memory DB used by the application.
Once started, it will open a browser window where following connection should be used:
Driver Class: org.h2.Driver
JDBC URL: jdbc:h2:tcp://localhost/mem:transfer-db
User Name: sa
Password: sa

Application RESTful Endpoints
-----------------------------
Once started, application exposes following endpoints:
- GET     /api/v1/accounts – returns list of accounts
- GET     /api/v1/accounts{id} – returns details about one account by provided ID
- GET     /api/v1/currencies – returns list of currencies
- GET     /api/v1/currencies{id} – returns details about one currency by provided ID
- GET     /api/v1/transactions – returns list of transactions
- GET     /api/v1/transactions{id} – returns details about one transaction by provided ID
- POST    /api/v1/transfers – processes money transfer operation

They can be used as following:
`curl -H "Content-Type: application/json" http://localhost:8080/api/v1/transactions`
`curl -d @sample1.json -H "Content-Type: application/json" -X POST http://localhost:8080/api/v1/transfers`

Application Design
------------------
The application heavily relies on Dropwizard framework, which is a collection of various tools for creating micro services.
Underneath it uses Jetty Servlet container, which uses a thread pool for incoming request; a dedicated thread is borrowed from the pool per every HTTP request.
In case HTTP request processing requires DB access, a DB connection is obtained from a pool.
Safe concurrency is ensured by DB means – records are exclusively locked while performing read-compare-write operations.
There is no ‘application’ related shared state used by the application, except for the actual DB, so no need to synchronize request processing by using Java means.

Random Notes / Reflection
-------------------------
- The design was chosen mainly because of rapid development possibility.
- There are several Unit and Integration test provided to demonstrate the usage, however actual coverage is very low (full coverage would require substantial amount of time).
- Presented design approach is suitable for small and medium size deployments, however it suffers from numerous drawbacks (see below).
- Performance and scalability are limited by DB as all requests hit DB and there is no caching (expect for DB internal caching).
- Each request uses its one thread, hence this design suffers from C10K problem.
- A proper design could rely on storing all the accounts in memory and write to disk only committed transactions.
- For highest possible performance, event sourcing should be considered together with ‘append-only’ DB instead of transactional SQL DB.

license: Unlicense

repository: gimesketvirtadieni/transfer-app

repo_name: gimesketvirtadieni/transfer-app


text:
# translate.vim
# This plugin is not maintained, please use [denops-translate.vim](https://github.com/skanehira/denops-translate.vim)
This is translate language plugin.

![](https://i.imgur.com/p3WsE8P.gif)

# Features
- translate

# Requirement
- curl
- vim 8.1.1513 or above/Neovim

# Installtion
You can use the plugin manager or Vim8 package manager.
eg: dein.vim

```toml
[[plugins]]
repo = 'skanehira/translate.vim'
```

# Usage
The default is to translate English into Japanese.

The language code is bellow.
https://cloud.google.com/translate/docs/languages

Translate current line
```vim
:Translate
```

Translate specified words
```vim
" result: こんにちは私の名前はゴリラです
:Translate hello my name is gorilla
```

Reverse between resource and target to translate when using "!"
```vim
" result: It's a gorilla
:Translate! ゴリラです
```

Translate selected lines
```vim
:'<,'>Translate
```

You can use below options
```vim
let g:translate_source = "en"
let g:translate_target = "ja"
let g:translate_popup_window = 0 " if you want use popup window, set value 1
let g:translate_winsize = 10 " set buffer window height size if you doesn't use popup window
```

You can also set key mappings.

```vim
nmap gr <Plug>(Translate)
vmap t <Plug>(VTranslate)
```

If you using popup window and you want yank translate result, you can use `y` to do it.

gha_language: Vim script


text:
# fi-is [![Build Status](https://travis-ci.org/FinalDevStudio/fi-is.svg?branch=master)](https://travis-ci.org/FinalDevStudio/fi-is)

A small general purpose check library with arithmetic, array, environments, object, presence, regexp, string, time and type check functions. Available for Node.js and the browser.

- No dependencies
- AMD, Node & browser ready

Originally meant as a drop-in replacement for and forked from [is.js](https://github.com/arasatasaygin/is.js).

### Usage
#### Node.js

Install with NPM:
```
npm install --save fi-is
```

Use in you application:
```js
var is = require('fi-is');

is.nodejs(); // true
is.number(0); // true
```

#### Browser
Install with Bower:
```
bower install --save fi-is
```

Include the non-minified script for testing and development:
```html
<script src="bower_components/fi-is/dist/fi-is.js"></script>
```

Or include the minified script for production:
```html
<script src="bower_components/fi-is/dist/fi-is.min.js"></script>
```

Or, better yet, bundle it with the rest of the scripts.

### Documentation
- [API](docs/index.md)
- [Arithmetic checks](docs/arithmetic.md)
- [Array checks](docs/array.md)
- [Environment checks](docs/environment.md)
- [Object checks](docs/object.md)
- [Presence checks](docs/presence.md)
- [RegExp checks](docs/regexp.md)
- [String checks](docs/string.md)
- [Time checks](docs/time.md)
- [Type checks](docs/type.md)

### Contributing
Please keep you code tidy and readable and document appropriately using the following schema:

```js
/**
 * Checks for awesomeness.
 *
 * @param {String} str It receives a string or whatever.
 * @return {Boolean} It must return a boolean.
 * @example
 * is.awesome('fi-is'); // true
 * is.awesome(1); // false
 */
is.awesome = function (str) {
 return is.string(str) && str === 'fi-is';
};
```

If the method has more than one argument or it's unnecessary to include all of them, define the method's interfaces below it:

```js
// ...

is.awesome.api['not'];
```

To build browser versions (dist):
```
gulp dist
```

To run tests:
```
npm test
```

To update the documentation files:
```
gulp docs
```

One-liner:
`gulp dist && npm test && gulp docs`

#### Contributors:
Many thanks to the [contributors](https://github.com/finaldevstudio/fi-is/graphs/contributors).

repository: SystemCico/tokenTest

repo_name: SystemCico/tokenTest


text:
localStorage memory for textareas
=================================

By Pablo Villalba for [Teambox](http://teambox.com) collaboration software.

Usage
-----

Saves textareas, inputs or selects to localStorage when the data-save-id attribute
is defined as a unique string identifier for that textarea.

    <input data-save-id="task-123-name"></input>
    <textarea data-save-id="task-123-body"></textarea>
    <select data-save-id="task-123-body">
      <option value="1">First</option>
      <option value="2">Second</option>
    </select>

- Typing on an input field will save its value locally every 200 ms.
- Clicking on an empty field will load the saved value if there is one.
- Calling $(selector).loadSavedTextareas() will restore input or textareas saved.

READ THE CODE to understand how it works, it's not so long :)

Notes
-----

- Depends on underscore.js, jQuery 1.7.
- You will need to manually clear localStorage if you need it.

Licence
-------

MIT Licence, do whatever you want with it :)


text:
# Omphalia flava (Cooke) F.H. Møller, 1945 SPECIES

#### Status
SYNONYM

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Fungi Faeroes 1(1): 260 (1945)

#### Original name
Agaricus umbelliferus f. flavus Cooke, 1883

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Basidiomycota/Agaricomycetes/Agaricales/Hygrophoraceae/Lichenomphalia/Lichenomphalia alpina/ Syn. Omphalia flava/README.md

repo_name: mdoering/backbone


text:
Packages
========
Writing code is great, but you don't want to write everything from scratch! How
do you get sets of code (libraries) written by other people? With a package
manager! The package manager for python is called `pip`. Want to see what
python packages are installed on your computer? Try this:
```
pip freeze
```
You'll get back a list of the packages and their versions. It might look
something like this.
```
Jinja2==2.7.2
MarkupSafe==0.21
Werkzeug==0.9.4
backports.ssl-match-hostname==<IP_ADDRESS>
gnureadline==6.3.3
ipython==2.0.0
pyzmq==14.2.0
tornado==3.2
wsgiref==0.1.2
```

The central location that pip searches for packages is the
[Python Package Index](https://pypi.python.org/pypi) (pypi). You can also
install from any location that puts the source code on the internet.
```
# Installs ipython from github
pip install<EMAIL_ADDRESS>
# Installs ipython from pypi
pip install ipython==2.0.0
```
**Note:** You'll see that the github version has 'rel-2.0.0' instead of '2.0.0'.
This is because the iPython team has made a
[git tag called 'rel-2.0.0'](https://github.com/ipython/ipython/tree/rel-2.0.0)
for the 2.0.0 version.

Virtualenv
----------
Sometimes you want to use a different version of a library then you have
installed on your system environment. For example, we have a project that needs
`ipython==1.2.0`, but our system has `ipython==2.0.0` installed. What do we do?
We use Virtualenv. Virtualenv creates a "virtual environment," a kind of sandbox
for packages.

1. Install [Homebrew](http://brew.sh/) - scroll to the bottom of the page and
follow the instructions
2. Install virtualenv. (Open the terminal and enter the following command. You
may have to enter your password)

    ```
    sudo pip install virtualenv virtualenvwrapper
    ```
    You have just installed a python package into your system!
3. **Magic**. Run these commands in your terminal.

    ```
    mkdir ~/.venv;
    echo "export WORKON_HOME=~/.venv" | tee -a ~/.bashrc;
    echo "source /usr/local/bin/virtualenvwrapper.sh" | tee -a ~/.bashrc;
    ```
    You have modified what your terminal runs whenever you open the Terminal!
    Close this Terminal window and open a new one ( + w,  + n)
4. Create a new virtual environment.

    ```
    mkvirtualenv setup-env
    ```
    You have now made a new virtual environment! If you ever want to use this
    environment again, simply run `workon setup-env` in your terminal.
5. You can now install any python package into this environment. Try installing
    ipython.

    ```
    pip install ipython==1.2.0
    # No sudo necessary
    ```

repository: micahhausler/getting-started

repo_name: micahhausler/getting-started


text:
# Corewar

![vm](/images/corewar_readme.gif)
*```The virtual machine visualizer (using ncurses library)```*

## Description
COREWAR is a 1984 programming game created by D. G. Jones and A. K. Dewdney in which two or more battle programs (called "warriors") compete for control of a virtual computer. These battle programs are written in an abstract assembly language called Redcode.

This project can be broken down into three distinctive parts:

• **The assembler:** This is the program that will compile champions and translate them from the assembly language into “Bytecode”. Bytecode is a machine code, which will be directly interpreted by the virtual machine.

• **The virtual machine:** It’s the “arena” where champions will be executed.
It offers various functions, all of which will be useful for the battle of the champions.

• **The champion:** Our task was to write the champion in assembly language which will fight in the arena against other champions.

The game ends when all the processes are dead. The winner is the last player
reported to be “alive”.

![winner](/images/winner.png)

## Usage
### Assembler:
```./asm [-h] [-e] [-d DIR] [-x] [-f FILE] [-l] <sourcefile.s> or: ./asm -z [-d DIR] <sourcefile.cor>```

**Assembler options:**
**-h** : prints the usage

**-e** : prints all the errors instead of only the first one

**-d** : DIR creates the .cor file to the directory DIR

**-x** : prints the hexdump

**-f** FILE : names the .cor file FILE

**-l** : prints memory leaks

**-z** : disassembles a .cor file to a .s file

### Corewar:
```./corewar [-dump N | -d N] [-a] [-l] [-v] [[-n N] file.cor] ```

**Corewar Options:**
**-n** : This flag assigns an id number to the specified champion. And players who did not receive such a number using the flag, first of the unused id's will be assigned

**-dump** : At the end of nbr_cycles of executions, the program dumps the memory on the standard output and quit the game. The memory is dumped in the hexadecimal format with 32 octets per line.

**-d** : At the end of nbr_cycles of executions, the program dumps the memory on the standard output and quit the game. The memory is dumped in the hexadecimal format with 64 octets per line.

**-a** : Prints output from "aff" (Default is to hide it)

**-l** : For each valid execution of the live instruction, the machine display: A process shows that player X (champion_name) is alive.

**-v** : A graphic interface for the virtual machine using nCurses.

## Compiling
You can clone this repository and compile both of the programs by running following command inside of your terminal:
```git clone https://github.com/kurval/Corewar.git corewar && cd corewar && make```

## Man page
You can view our manpage by running: ```make man``` and set environment variable ```export MANPATH=./sources/man```

Now you can view asm and corewar manpages:
```man asm``` or ```man corewar```

![corewar_man](/images/man.png)

## Contributors:
[@anntuomi](https://github.com/anntuomi) : assembler, test scripts
[@janettem](https://github.com/janettem) : assembler, vm operations
[@Konjuhaj](https://github.com/Konjuhaj) : vm parsing, deassembler
[@kurval](https://github.com/kurval) : vm execution, operations, visualizer

For more details view my
GitHub

<svg width="2em" height="2em" viewBox="0 0 16 16" class="bi bi-arrow-left-circle-fill" fill="black" xmlns="http://www.w3.org/2000/svg">
  <path fill-rule="evenodd" d="M16 8A8 8 0 1 1 0 8a8 8 0 0 1 16 0zm-4.5.5a.5.5 0 0 0 0-1H5.707l2.147-2.146a.5.5 0 1 0-.708-.708l-3 3a.5.5 0 0 0 0 .708l3 3a.5.5 0 0 0 .708-.708L5.707 8.5H11.5z"/>
</svg>

Go back to home page


text:
# Kotlin Sample App

This is our sample App to show you how to integrate our SDK in a Kotlin app using modern Navigation
components. If you use classic Activity navigation, you can check out our Java Sample App in the
[java-sample](../java-sample) directory.

repository: snabble/Android-SDK

gha_language: Kotlin

repo_name: snabble/Android-SDK


text:
# 10 - Transformation guidance from farm solutions to app model #

----------

This module concentrates on actual transformation process from existing full trust customizations to the app model based functionalities. It also covers some practices to be taken into account in full trust customization / farm solution implementations to minimize work and impact when actual transformation to app model will happen.

**Agenda**
- Transformation process
- Transformation approaches
- Element Replacement approaches
- Farm solution considerations

**Key recommendations**
- Make sure that you have detailed inventory of your customizations
- Use analyses tooling for technical analyses
- Transform end user experience, not code - it's not one to one code analyses
- Understand impact of farm solutions

**Lab 1 - Replacement of files provisioned via Modules in Full Trust Solutions**
In this lab you will learn how to replace existing master pages and page layouts which have been deployed to an On-Premises SharePoint Server via Modules in a Full Trust Solution. This will involve deploying new files to replace those deployed via Modules and updating the existing usages of these files to remove the dependency on the files which were deployed via declarative means.

- [Lab manual](10-1 Replacement of files deployed via Modules/Lab.md)

**Lab 2 - Replacement of lists provisioned from list templates in Full Trust Solutions**
In this lab you will learn how to detect existing lists and libraries, which have been created from a custom list template deployed into an On-Premises SharePoint Server in a Full Trust Solution. This will involve creating new lists to replace those, configuring them appropriately then transferring the existing content from the original list.

- [Lab manual](10-2 Replacing Lists Created from Custom Templates/Lab.md)

**Lab 3 - Content Type and Site columns replacements**
In this lab you will learn how to replace existing content types by deploying new content types and updating the content to the new content type with new site columns using remote provisioning.

- [Lab manual](10-3 Content Type and Site columns replacements/Lab.md)

**Lab 4 - Replacement of web parts with app parts**
In this lab you will learn how to replace existing web parts by deploying a SharePoint Provider hosted app and updating the content to use an App Part hosted in the Provider hosted app in place of Web Parts using Full Trust Code.

- [Lab manual](10-4 Web Part Replacement Using CAM/Lab.md)

**Demos**
- SPCAF tooling in practice - Demonstration of free SPCAF tool for app model inventory
- [App pre-register and side loading](https://github.com/OfficeDev/PnP/tree/dev/Samples/Core.SideLoading)

----------

*Notice that we will keep on updating this material based on your input and work being done in the [Office 365 Developer Patterns and Practices program](http://aka.ms/officedevpnp). You can provide us input directly using the [Office 365 Developer Patterns & Practices Yammer group](http://aka.ms/officedevpnpyammer)*

![](https://camo.githubusercontent.com/a732087ed949b0f2f84f5f02b8c79f1a9dd96f65/687474703a2f2f692e696d6775722e636f6d2f6c3031686876452e706e67)

url: https://raw.githubusercontent.com/keithmg/TrainingContent/79988e700abefcdd834c0ea9583c48c124175933/O3658/10 Transformation guidance from farm solutions to app model/Readme.md

repository: keithmg/TrainingContent

repo_name: keithmg/TrainingContent


text:
---
layout: post
title: 'GMap maplet example: Nuke It!'
slug: gmapnuke
date: 2009-02-26
categories:
- General
tags: []
status: publish
type: post
published: true
---

This is a very cool example of javascript overlay with google maps.

Target someone, something, somewhere, and see (in a fun google map kind of way) what destruction you would cause.

The example and full post can be seen on the authors site: http://www.carloslabs.com/node/16

As Oppenheimer famously quoted from the Bhagavad Gita:

"Now I am become Death, the destroyer of worlds." ( or atleast Norwich, from the comfort of my desk )

gha_language: CSS


text:
Base16 for Geany
================
[Geany](http://geany.org) is a text editor using the GTK2 toolkit with basic
features of an integrated development environment. This is a
[Base16](https://github.com/chriskempson/base16) color scheme for it, which was
built using the [Base16 Builder](https://github.com/chriskempson/base16-builder).

![Base16 Default Dark](https://raw.github.com/robloach/base16-geany/master/base16-default.dark.png)

Installation
------------
1. Copy the files to your `~/.config/geany/colorschemes` directory.
2. Choose the scheme at View -> Editor -> Color Schemes.

Contributing
------------
Pull requests can be made against [Base16 Builder](http://github.com/chriskempson/base16-builder).
Feel free to communicate in the [Base16 for Geany issue queue](https://github.com/RobLoach/base16-geany/issues)
about any new additions.

License
-------
Base16 for Geany is licensed under the [MIT License](https://github.com/robloach/base16-geany/blob/master/LICENSE.md)


text:
### [CVE-2017-15814](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-15814)
![](https://img.shields.io/static/v1?label=Product&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=n%2Fa&color=brighgreen)

### Description

In Android for MSM, Firefox OS for MSM, QRD Android, with all Android releases from CAF using the Linux kernel, in msm_flash_subdev_do_ioctl of drivers/media/platform/msm/camera_v2/sensor/flash/msm_flash.c, there is a possible out of bounds read if flash_data.cfg_type is CFG_FLASH_INIT due to improper input validation. This could lead to local information disclosure with System execution privileges needed. User interaction is not needed for exploitation.

### POC

#### Reference
No PoCs from references.

#### Github
- https://github.com/ARPSyndicate/cvemon

repository: trickest/cve

gha_language: HTML

repo_name: trickest/cve


text:
# Services and Components

Components, services and dependencies:

![](images/component.png)

As every technology, Windsor has certain basic concepts that you need to understand in order to be able to properly use it. Fear not - they may have scary and complicated names and abstract definitions but they are quite simple to grasp.

## Service

:information_source: **Service in Windsor and WCF service:** The term service is extremely overloaded and has become even more so in recent years. Services as used in this documentation are a broader term than for example WCF services.

First concept that you'll see over and over in the documentation and in Windsor's API is **service**. Actual definition goes somewhat like this: "*service is an abstract contract describing some cohesive unit of functionality*".

Now in plain language, let's imagine you enter a coffee shop you've never been to. You talk to the barista, order your coffee, pay, wait and enjoy your cup of perfect Cappuccino. Now, let's look at the interactions you went through:

* specify the coffee you want
* pay
* get the coffee

They are the same for pretty much every coffee shop on the planet. They are the coffee shop service. Does it start making a bit more sense now? The coffee shop has clearly defined, cohesive functionality it exposes - it makes coffee. The contract is pretty abstract and high level. It doesn't concern itself with "implementation details"; what sort of coffee-machine and beans does the coffee shop have, how big it is, and what's the name of the barista, and color of her shirt. You, as a user don't care about those things, you only care about getting your cappuccino, so all the things that don't directly impact you getting your coffee do not belong as part of the service.

Hopefully you're getting a better picture of what it's all about, and what makes a good service. Now back in .NET land we might define a coffee shop as an interface (since interfaces are by definition abstract and have no implementation details you'll often find that your services will be defined as interfaces).

```csharp
public interface ICoffeeShop
{
   Future<Coffee> GetCoffee(CoffeeRequest request);
}
```

The actual details obviously can vary, but it has all the important aspects. The service defined by our `ICoffeeShop` is high level. It defines all the aspects required to successfully order a coffee, and yet it doesn't leak any details on who, how or where prepares the coffee.

If coffee is not your thing, you can find examples of good contracts in many areas of your codebase. `IController` in ASP.NET MVC, which defines all the details required by ASP.NET MVC framework to successfully plug your controller into its processing pipeline, yet gives you all the flexibility you need to implement the controller, whether you're building a social networking site, or e-commerce application.

If that's all clear and simple now, let's move to the next important concept.

## Component

Component is related to service. Service is an abstract term and we're dealing with concrete, real world. A coffee shop as a concept won't make your coffee. For that you need an actual coffee shop that puts that concept in action. In C# terms this usually means a class implementing the service will be involved.

```csharp
public class Starbucks: ICoffeeShop
{
   public Future<Coffee> GetCoffee(CoffeeRequest request)
   {
      // some implementation
   }
}
```

So far so good. Now the important thing to remember is that, just as there can be more than one coffee shop in town, there can be multiple components, implemented by multiple classes in your application (a Starbucks, and a CofeeClub for example).

It doesn't end there! If there can be more than one Starbucks in town, there can also be more than one component backed by the same class. If you've used NHibernate, in an application accessing multiple databases, you probably had two session factories, one for each database. They are both implemented by the same class, they both expose the same service, yet they are two separate components (having different connection strings, they map different classes, or potentially one is talking to Oracle while the other to SQL Server).

It doesn't end there (still)! Who said that your local French coffee shop can only sell coffee? How about a tarte or fresh baguette to go with the coffee? Just like in real life a coffee shop can serve other purposes a single component can expose multiple services.

One more thing before we move forward. While not implicitly stated so far it's probably obvious to you by now that a component provides a service (or a few). As such all the classes in your application that do not really provide any services will not end up as components in your container. Domain model classes, DTOs are just a few examples of things you will not put in a container.

## Dependency

We're almost there. To get the full picture we need to talk about dependencies first.

A component working to fulfill its service is not living in a vacuum. Just like a coffee shop depends on services provided by utility companies (electricity), its suppliers (to get the beans, milk etc) most components will end up delegating non-essential aspects of what they're doing to others.

Now let me repeat one thing just to make sure it's obvious. Components depend on services of other components. This allows for nicely decoupled code where your coffee shop is not burdened with details of how the milk delivery guy operates.

In addition to depending on other component's services your components will also sometimes use things that are not components themselves. Things like connectionStrings, names of servers, values of timeouts and other configuration parameters are not services (as we discussed previously) yet are valid (and common) dependencies of a component.

In C# terms your component will declare what dependencies it requires usually via constructor arguments or settable properties. In some more advanced scenarios dependencies of a component may have nothing to do with the class you used as implementation (remember, the concept of a component is not the same as a class that might be used as its implementation), for example when you're applying interceptors. This is advanced stuff however so you don't have to concern yourself with it if you're just starting out.

## Putting it all together

So now lets put it all together. To effectively use a container we're dealing with small components, exposing small, well defined, abstract services, depending on services provided by other components, and on some configuration values to fulfil contracts of their services.

You will end up having many small, decoupled components, which will allow you to rapidly change and evolve your application limiting the scope of changes, but the downside of that is you'll end up having plenty small classes with multiple dependencies that someone will have to manage.

That is the job of a container.

repository: DamirAinullin/Windsor

repo_name: DamirAinullin/Windsor


text:
hxDaedalus-Examples
===================

This is the examples repository for the Haxe version of the as3 Daedalus-lib.

These examples require the current haxe hxDaedalus library, which can be found here:
https://github.com/Justinfront/hxDaedalus

You can view some of the examples:
[Basic](http://rawgit.com/Justinfront/hxDaedalus-Examples/master/hxDaedalus-Examples/web/DaedalusBasic.html)
[Pathfinding](http://rawgit.com/Justinfront/hxDaedalus-Examples/master/hxDaedalus-Examples/web/DaedalusPathfinding.html)
[Maze](http://rawgit.com/Justinfront/hxDaedalus-Examples/master/hxDaedalus-Examples/web/GridMazeDemo.html)

Licence is MIT.

repository: hxDaedalus/hxDaedalus-Examples

repo_name: hxDaedalus/hxDaedalus-Examples


text:
# EdSketch: Execution-Driven Sketching for Java

Master branch:
- v0.1 March 9, 2017: SPIN submission. Basic sketching functions that involves expression, assignments, and condition expressions.

## Overview

EdSketch executes test cases to synthesize sketches with lazy candidate generation. EdSketch will not generate concrete candidates for a hole until the test execution reaches the hole.

When the test execution first reaches a hole,  EdSketch initializes the hole's candidates based on the given visible variables and default values. Each candidate is assigned a unique identifier, which is its index in the vector. Each hole's candidate
identifier is initialized as -1, indicating that EdSketch
has not selected a candidate for this hole.

During the test execution, the sketch engine selects an identifier starting from 0,  and the candidate with the corresponding identifier is used to fill in the hole. The execution continues with this selection until it encounters a runtime exception or a test failure, which leads to a backtrack with an increment of the candidate identifier, indicating the next candidate at runtime (incrementCounter()).

Whenever the program backtracks, the candidate identifier is reset as -1 to fill a new candidate (reset()). The process terminates when a complete program that passes all tests is found or the space of candidate programs is exhaustively explored.

repository: SketchFix/EdSketch

repo_name: SketchFix/EdSketch


text:
---
author: adam
date: '2008-06-17 08:00:14'
layout: post
slug: ok-so-i-lied-back-to-mac-winxp
status: publish
title: Ok, so I lied - Back to Mac & WinXP
wordpress_id: '44'
categories:
- Tech
---

Yesterday, I posted about how I was giving up OS X after 3 months of use.
Well, after 24 hours of use, I remembered why I tried to switch to mac to
start with...activation.  I'm one of those people that likes to reformat a
machine when it's getting too much crud - after all, as a software developer,
I try out new things when they come out and that's not really a good thing for
the system if you want to keep it clean and fast.  The problem, is that I
don't really want to tie Vista to my MacBook since I may want to go back to OS
X at some point...  I remembered I had my dual core Athlon 64 desktop w/
triple monitors just sitting in a closet, so found some desk space and fired
it up.  It's so much easier to get my .NET development on using my desktop.
I'm sure it's just habit, but it just doesn't feel right on the laptop (and I
miss my third screen).

So, now my MacBook is transitioning back to OS X Leopard (looking forward to
Snow Leopard though if they really do speed things up), but my main workhorse
is my trusty old desktop.  I really hate not using Vista since I purchased it
at retail, but XP just feels better (and Vista doesn't like my desktop...but
XP flies on it thanks to the ton o' RAM and 10K RPM SATA drive).

I'm really surprised that I didn't like having a dedicated Vista laptop, but
it just didn't feel right once everything was said and done.  With this new
setup, things seem just right...old habits die hard.

repository: adambyram/adambyramcom

extension: markdown

repo_name: adambyram/adambyramcom


text:
# Provision sites in batches with the app model
## Requires
*
## License
* Apache License, Version 2.0
## Technologies
* SharePoint Server 2013
* apps for SharePoint
## Topics
* apps for SharePoint
## IsPublished
* True
## ModifiedDate
* 2015-03-12 05:08:10
## Description

We replaced this sample with a newer sample on GitHub. To use or contribute to the sample on GitHub, see
Provisioning.Batch.

This sample provider-hosted app for SharePoint shows how to create SharePoint 2013 site collections by using the client object model. This app for SharePoint runs as a console application that you can host remotely, and it uses the app only permission policy.
 The app requires full control at the tenant scope.

This sample requires the following:

An Office 365 SharePoint site

Note: The code that creates a site collection will not work on an Office 365 Developer Site.

Visual Studio 2012 and Office Developer Tools for Visual Studio 2012 installed on your development computer

A Windows Azure account with permissions to deploy a cloud service

Windows Azure SDK for .NET (VS 2012) 1.8

The sample app contains the following:

Batch Provisioning project, which contains the AppManifest.xml file. This file registers the provider-hosted app with SharePoint.

Batch Provisioning Console project, which contains:

App.config file: Contains the client id and secret for the app

Sites.xml: Contains a list of the names of the site collections that the app will create

Program.cs: Contains the code that provisions the site collections listed in Sites.xml

TokenHelper.cs: Contains the helper code that enables the app to get the required permissions for creating site collections. This file is not a default component of the console application template in Visual Studio 2013. You can get this
 file by creating a provider-hosted or autohosted app for SharePoint and copying the file from the remote web application to the console app project.

Batch ProvisioningWeb project, which contains the TokenHelper.cs file and also the default components of a provider-hosted app. You can deploy this web application to a Windows Azure site to make sure that your app's credentials are working.

Related content

Office 365 Developer Patterns and Practices

repository: techbuzzz/Samples-archive-msdn-products

path: /Microsoft Office Developer Documentation Team/Provision-sites-in-batches-with-the-app-model-26954/Readme.md

repo_name: techbuzzz/Samples-archive-msdn-products


text:
# Locus.Threading

Simple Threading Library for Dot Not Core\
Actor based concurrency with **Task** & **async await** support

## Examples

How to create actor(fiber)
```cs
var myFiber = new TaskFiber();
```
\
How to enqueue a action or a task.
```cs
myFiber.Enqueue(myTask);

//or
myFiber.Enqueue(myAction);

//you can also enqueue a Func<T> or Task<T>
myFiber.Enqueue(new Task<int>(() => 0));
```
\
The Enqueue function returns Task(or Task<T\> ) so you can await it
```cs
await myFiber.Enqueue(myAction);

//or
await myFiber.Enqueue(myTask);

//or
var myInt = await myFiber.Enqueue(new Task<int>(() => 0));
```
But **DO NOT** enqueue async method directly
```cs
void SomeFunction()
{
    myFiber.Enqueue(SomeAsyncFunction()); // this will raise an exception that task is already started
}

async Task SomeAsyncFunction()
{
    ...
}
```
\
**Async Await Support!**

An **await** keyword captures current context and use it later execution.\
So after calling **await** keyword, your code will be handled by unknown threadpool thread.

But each **TaskFiber** have it's own custom logical Synchronization Context. \
**TaskFiber**'s SynchronizationContext will remember current Fiber as a returning Thread. \
After called **await** we'll safly be back to our calling Fiber.

```cs
async Task SomeFunction()
{
    //this will await full async execution
    await SomeAsyncFunction("Direct call"));

    //this will await just enqueueing and 1st iteration of SomeAsyncFunction.
    //(right before another await inside function)
    await myFiber.Enqueue(() => SomeAsyncFunction("Action Style"));
}

async Task SomeAsyncFunction(string log)
{
    //You can check where is your context anytime
    Console.WriteLine(log + " : "  + myFiber.IsCurrentThread);
    // - "Direct call : false"
    // - "Action Styple : true"

    //if you call this function directly, call one of following to get into TaskFiber execution
    await myFiber;
    await Task.Yield().IntoFiber(myFiber);
    await myFiber.IntoFiber();

    //Now you're in myFiber's execution chain.
    Console.WriteLine(log + " : "  + myFiber.IsCurrentThread);
    // - "Direct call : true"
    // - "Action Styple : true"

    await Task.Delay(1000);
    //when calling above await keyword, the execution context will be stored
    Console.WriteLine(myFiber.IsCurrentThread);
    // - "Direct call : true"
    // - "Action Styple : true"
}
```

There is also MessageFiber<T\> class for better performance. Take a look.
\

## Motivation

When I was in .Net childhood, I fall in love deeply with **Retlang** which is a concorrency library like **Jetlang** in Java world.\
It gave me simple approches how to use multicore environment without race conditions, like functional languages such as **Erlang**.\
And then, **TPL**(Task Parallel Library) and **async await** keywords are introduced, my codes are get simplar than before.\
But still, I wanted to use somewhat **Actor Based Concurrency** as before, I made a simple library that utilize Task and 'async await' funtionality.

## Installation

Download source files and include them into your project.\
Or use nuget package console.

```
PM > Install-Package Locus.Threading
```
Works too.

## License

[MIT](https://raw.githubusercontent.com/locus84/Threading/c6f053aac6840c133dc7f2a302de8799ea6daf36/LICENSE)


text:
# Worker - acquire

The `acquire` method tries to acquire the lock. The method allows to wait for the lock to become available. When the lock is acquired, the return value is `True`, otherwise it returns `False`.

- `timeout`: How much time (in seconds) to wait until the lock is acquireable.
- `check_interval`: How frequently (in seconds) to check the lock.
- `ttl`: Once the lock is acquired, how long (in seconds) should be its lifetime.

## Definition

```python
def acquire(
    self,
    timeout: typing.Optional[float] = None,
    check_interval: float = 1.0,
    ttl: int = 60,
) -> bool
```

## Examples

=== "Simple"
    ```python
    def work(
        self,
        task,
    ):
        single_access_api_url = task.kwargs['single_access_api_url']

        lock = self.lock('single_access_api')
        acquired = lock.acquire(
            timeout=10,
            check_interval=1.0,
            ttl=60,
        )
        if acquired:
            try:
                response = requests.get(single_access_api_url)
            finally:
                lock.release()
    ```

repository: yoavsoda/sergeant

repo_name: yoavsoda/sergeant