text:
#A second supply to the draft of a great act or system, concerning the regulation of the law. Or, A fall of above twenty nine in thirty writts of error and of nine parts in ten of the charge, in those after to be necessary : and a prevention of delays, inconveniences, and mischeifs in future, which formerly have happened by such writs : In order to the saving yearly to the people many thousands of pounds, part of the severall millions and odd of pounds by the Anti-Levellers Antidote mentioned to be saved. With a short justification of the funerall of tythes of impropriators and symonists, &c. Rejoyned unto by an angry pamphlet, intituled, A vindication of a short treatise of tythes, &c. / Published by those who published the Funerall, &c.#
A second supply to the draft of a great act or system, concerning the regulation of the law. Or, A fall of above twenty nine in thirty writts of error and of nine parts in ten of the charge, in those after to be necessary : and a prevention of delays, inconveniences, and mischeifs in future, which formerly have happened by such writs : In order to the saving yearly to the people many thousands of pounds, part of the severall millions and odd of pounds by the Anti-Levellers Antidote mentioned to be saved. With a short justification of the funerall of tythes of impropriators and symonists, &c. Rejoyned unto by an angry pamphlet, intituled, A vindication of a short treatise of tythes, &c. / Published by those who published the Funerall, &c.

##General Summary##

**Links**

[TCP catalogue](http://www.ota.ox.ac.uk/tcp/)  •
[HTML](http://tei.it.ox.ac.uk/tcp/Texts-HTML/free/B05/B05779.html)  •
[EPUB](http://tei.it.ox.ac.uk/tcp/Texts-EPUB/free/B05/B05779.epub) •
[Page images (Historical Texts)](https://historicaltexts.jisc.ac.uk/eebo-51617443e)

**Availability**

This keyboarded and encoded edition of the work described above is co-owned by the
    institutions providing financial support to the Early English Books Online Text Creation
    Partnership. This text is available for reuse, according to the terms of  Creative Commons 0 1.0 Universal
    licence. The text can be copied, modified, distributed and performed, even for commercial
    purposes, all without asking permission.

**Major revisions**

1. __2014-07 __ __SPi Global__ *Keyed and coded from ProQuest page images *
1. __2015-01 __ __Zev Berger __ *Sampled and proofread *
1. __2015-01 __ __Zev Berger__ *Text and markup reviewed and edited *
1. __2015-03 __ __pfs__ *Batch review (QC) and XML conversion *
1. __2021-05 __ __lb__ *TEI P5 conversion *

##Content Summary##

#####Body#####

1. A SECOND SUPPLY To the Draft of a great Act or Cystem, concerning the Regulation of the LAW.

    _ A stort Justification of the funerall of Tythes, &c.

**Types of content**

  * Oh, Mr. Jourdain, there is **prose** in there!

There are 8 **omitted** fragments!
 @__reason__ (8) : illegible (8)  •  @__resp__ (8) : #uom (8)  •  @__extent__ (8) : 1 word (2), 1 letter (2), 1 span (4)

**Character listing**

|Text|string(s)|codepoint(s)|
|---|---|---|
|General Punctuation|•…|8226 8230|
|Geometric Shapes|◊|9674|
|CJKSymbolsandPunctuation|〈〉|12296 12297|

##Tag Usage Summary##

###Header Tag Usage###

|No|element name|occ|attributes|
|---|---|---|---|
|1.|__availability__|1||
|2.|__biblFull__|1||
|3.|__change__|5||
|4.|__date__|7| @__when__ (1) : 2016-02 (1)|
|5.|__editorialDecl__|1||
|6.|__encodingDesc__|1||
|7.|__extent__|2||
|8.|__fileDesc__|1||
|9.|__idno__|7| @__type__ (7) : DLPS (1), EEBO-CITATION (1), VID (1), EEBO-PROQUEST (1), STC (2), OCLC (1)|
|10.|__keywords__|1| @__scheme__ (1) : http://authorities.loc.gov/ (1)|
|11.|__label__|5||
|12.|__langUsage__|1||
|13.|__language__|1| @__ident__ (1) : eng (1)|
|14.|__listPrefixDef__|1||
|15.|__note__|7||
|16.|__notesStmt__|2||
|17.|__p__|11||
|18.|__prefixDef__|2| @__ident__ (2) : tcp (1), char (1)  •  @__matchPattern__ (2) : ([0-9\-]+):([0-9IVX]+) (1), (.+) (1)  •  @__replacementPattern__ (2) : http://eebo.chadwyck.com/downloadtiff?vid=$1&page=$2 (1), https://raw.githubusercontent.com/textcreationpartnership/Texts/master/tcpchars.xml#$1 (1)|
|19.|__profileDesc__|1||
|20.|__projectDesc__|1||
|21.|__pubPlace__|2||
|22.|__publicationStmt__|2||
|23.|__publisher__|2||
|24.|__ref__|4| @__target__ (4) : https://creativecommons.org/publicdomain/zero/1.0/ (1), http://www.textcreationpartnership.org/docs/. (1), https://textcreationpartnership.org/faq/#faq05 (1), https://github.com/textcreationpartnership (1)|
|25.|__relatedItem__|1| @__type__ (1) : facs (1)  •  @__target__ (1) : https://data.historicaltexts.jisc.ac.uk/view?pubId=eebo-e (1)|
|26.|__revisionDesc__|1||
|27.|__seriesStmt__|1||
|28.|__sourceDesc__|1||
|29.|__term__|2| @__type__ (2) : topical_term (2)|
|30.|__textClass__|1||
|31.|__title__|3||
|32.|__titleStmt__|2||

###Text Tag Usage###

|No|element name|occ|attributes|
|---|---|---|---|
|1.|__body__|1||
|2.|__desc__|8||
|3.|__div__|2| @__type__ (2) : text (1), part (1)|
|4.|__g__|79| @__ref__ (79) : char:EOLhyphen (79)|
|5.|__gap__|8| @__reason__ (8) : illegible (8)  •  @__resp__ (8) : #uom (8)  •  @__extent__ (8) : 1 word (2), 1 letter (2), 1 span (4)|
|6.|__head__|5| @__type__ (3) : sub (3)|
|7.|__hi__|173||
|8.|__p__|39||
|9.|__pb__|8| @__n__ (8) : 1 (1), 2 (1), 3 (1), 4 (1), 5 (1), 6 (1), 7 (1), 8 (1)  •  @__facs__ (8) : tcp:175366:1 (1), tcp:175366:2 (2), tcp:175366:3 (2), tcp:175366:4 (2), tcp:175366:5 (1)|
|10.|__seg__|1| @__rend__ (1) : decorInit (1)|
|11.|__trailer__|1||


text:
# CNN-Image-Classification
This contains code for various curiosity-quenching models that were implemented because of wanting to understand the nature and behaviour of Neural Nets.

Models implemented for Image Classification out of wanting to understand the working of RNNs:

1. RNN LSTM on Image Pixels, one row at a time
2. RNN LSTM on Global Image features: Col Histogram  and gist512, one row at a time.
3. RNN LSTM on Local Image features, one row at a time as sequential input.

repository: hanskrupakar/CNN-Image-Classification

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: hanskrupakar/CNN-Image-Classification


text:
---
title: Environmental groups seek court action
tags:
  - Apr 1978
---

Environmental groups seek court action to stop the Fisher Island development. [Map]

Newspapers: **Miami Morning News or The Miami Herald**

Page: **2**, Section: **B**

license: MIT


text:
---
layout: page
title: Toolkits for Analyzing Multi-modal ML & AI Applications
img: /assets/img/multimodal0.jpg
importance: 2
category: Application Characterization Methods
---
Multi-modal neural networks have become increasingly pervasive in today's AI application domains due to their superior accuracy by fusing various modalities. However, they present many unique characteristics such as multi-stage execution, frequent synchronization and high heterogeneity, which are not well understood in the system and architecture community. In this project, we aim to present and characterize a set of multi-modal neural network workloads of different sizes at inference stage. We also target on exploring their important implications from system and architecture aspects. We hope that our work can help guide future software/hardware
design and optimization for efficient inference of multi-modal DNN applications.

extension: markdown


text:
---
sort: 1
---

# Code

source: `{{ page.path }}`

{% include list.liquid all=true %}

Coding starters

## Text editors

The first step in your coding journey is to download yourself a good text editor.
While you most systems come with a basic built-in editor (e.g. `TextEdit` for MacOS or `notepad` for windows) its best to find one you like early one.

My favourite is [atom](https://atom.io/) - which is **FREE**.

Others include:

* [Sublime Text](https://www.sublimetext.com/) - **PAID**
* [Notepad++](https://notepad-plus-plus.org/)
* [TextMate](https://macromates.com/)

## Etherpad

An etherpad is an excellent tool to use for teaching and workshops. It provides a communal notepad that everyone can access - provide a single link and you can drop in any information, bits of code, webpage links, resources etc in this central place rather than having people rely on copying code correctly from a screen.

* [etherpad wikimedia](https://etherpad.wikimedia.org/)
* [pad carpentries](https://pad.carpentries.org/)
* [pad riseup](https://pad.riseup.net/)
* [pad carpentries](https://pad.carpentries.org/)


text:
---
schema: 2.0.0
applicable: SharePoint Online
online version: https://pnp.github.io/powershell/cmdlets/Register-PnPAzureADApp.html
external help file: PnP.PowerShell.dll-Help.xml
title: Register-PnPAzureADApp
---

# Register-PnPAzureADApp

## SYNOPSIS
Register an Azure AD App and optionally creates a new self-signed certificate to use with the application registration.

## SYNTAX

### Generate Certificate
```powershell
Register-PnPAzureADApp -ApplicationName <String>
                                       -Tenant <String>
                                       [-Username <String>]
                                       [-Password <SecureString>]
                                       [-DeviceLogin]
                                       [-Interactive]
                                       [-CommonName <String>]
                                       [-OutPath <String>]
                                       [-Store <StoreLocation>]
                                       [-GraphApplicationPermissions <Permission[]>]
                                       [-GraphDelegatePermissions <Permission[]>]
                                       [-SharePointApplicationPermissions <Permission[]>]
                                       [-SharePointDelegatePermissions <Permission[]>]
                                       [-Country <String>]
                                       [-State <String>]
                                       [-Locality <String>]
                                       [-Organization <String>]
                                       [-OrganizationUnit <String>]
                                       [-ValidYears <Int>]
                                       [-CertificatePassword <SecureString>]
                                       [-NoPopup]
                                       [-LogoFilePath <string>]
```

### Existing Certificate
```powershell
Register-PnPAzureADApp  -CertificatePath <String>
                        -ApplicationName <String>
                        -Tenant <String>
                        [-Username <String>]
                        [-Password <SecureString>]
                        [-DeviceLogin]
                        [-Interactive]
                        [-GraphApplicationPermissions <Permission[]>]
                        [-GraphDelegatePermissions <Permission[]>]
                        [-SharePointApplicationPermissions <Permission[]>]
                        [-SharePointDelegatePermissions <Permission[]>]
                        [-CertificatePassword <SecureString>]
                        [-NoPopup]
                        [-LogoFilePath <string>]
```

## DESCRIPTION
Registers an Azure AD App and optionally creates a new self-signed certificate to use with the application registration. You can login either with username/password or you can use the -DeviceLogin option if your tenant has been configured for Multi-Factor Authentication.

Note: if you want to use the newly created app to authentication with username/password you will have to make a modification to the app. Navigate to the application registration in your Azure AD, select the Authentication section, and set `Allow public client flows` to `yes`. Alternatively, navigate to the `Manifest` section and set `allowPublicClient` to `true`.

## EXAMPLES

### ------------------EXAMPLE 1------------------
```powershell
Register-PnPAzureADApp -ApplicationName TestApp -Tenant yourtenant.onmicrosoft.com -Store CurrentUser -Username<EMAIL_ADDRESS>-Password (Read-Host -AsSecureString -Prompt "Enter Password")
```

Creates a new Azure AD Application registration, creates a new self signed certificate, and adds it to the local certificate store. It will upload the certificate to the azure app registration and it will request the following permissions: Sites.FullControl.All, Group.ReadWrite.All, User.Read.All

### ------------------EXAMPLE 2------------------
```powershell
Register-PnPAzureADApp -ApplicationName TestApp -Tenant yourtenant.onmicrosoft.com -CertificatePath c:\certificate.pfx -CertificatePassword (ConvertTo-SecureString -String "password" -AsPlainText -Force) -Username<EMAIL_ADDRESS>-Password (Read-Host -AsSecureString -Prompt "Enter password")
```

Creates a new Azure AD Application registration which will use the existing private key certificate at the provided path to allow access. It will upload the provided private key certificate to the azure app registration and it will request the following permissions: Sites.FullControl.All, Group.ReadWrite.All, User.Read.All

### ------------------EXAMPLE 3------------------
```powershell
Register-PnPAzureADApp -ApplicationName TestApp -Tenant yourtenant.onmicrosoft.com -Store CurrentUser -GraphApplicationPermissions "User.Read.All" -SharePointApplicationPermissions "Sites.Read.All" -Username<EMAIL_ADDRESS>-Password (Read-Host -AsSecureString -Prompt "Enter Password")
```

Creates a new Azure AD Application registration, creates a new self signed certificate, and adds it to the local certificate store. It will upload the certificate to the azure app registration and it will request the following permissions: Sites.Read.All, User.Read.All

### ------------------EXAMPLE 4------------------
```powershell
Register-PnPAzureADApp -ApplicationName TestApp -Tenant yourtenant.onmicrosoft.com -OutPath c:\ -CertificatePassword (ConvertTo-SecureString -String "password" -AsPlainText -Force) -Username<EMAIL_ADDRESS>-Password (Read-Host -AsSecureString -Prompt "Enter Password")
```

Creates a new Azure AD Application registration, creates a new self signed certificate, and stores the public and private key certificates in c:\. The private key certificate will be locked with the password "password". It will upload the certificate to the azure app registration and it will request the following permissions: Sites.FullControl.All, Group.ReadWrite.All, User.Read.All

### ------------------EXAMPLE 5------------------
```powershell
Register-PnPAzureADApp -DeviceLogin -ApplicationName TestApp -Tenant yourtenant.onmicrosoft.com -CertificatePath c:\certificate.pfx -CertificatePassword (ConvertTo-SecureString -String "password" -AsPlainText -Force)
```

Creates a new Azure AD Application registration and asks you to authenticate using device login methods, creates a new self signed certificate, and adds it to the local certificate store. It will upload the certificate to the azure app registration and it will request the following permissions: Sites.FullControl.All, Group.ReadWrite.All, User.Read.All

### ------------------EXAMPLE 6------------------
```powershell
Register-PnPAzureADApp -Interactive -ApplicationName TestApp -Tenant yourtenant.onmicrosoft.com -CertificatePath c:\certificate.pfx -CertificatePassword (ConvertTo-SecureString -String "password" -AsPlainText -Force)
```

Creates a new Azure AD Application registration and asks you to authenticate using username and password, creates a new self signed certificate, and adds it to the local certificate store. It will upload the certificate to the azure app registration and it will request the following permissions: Sites.FullControl.All, Group.ReadWrite.All, User.Read.All

### ------------------EXAMPLE 7------------------
```powershell
Register-PnPAzureADApp -ApplicationName TestApp -Tenant yourtenant.onmicrosoft.com -CertificatePath c:\certificate.pfx -CertificatePassword (ConvertTo-SecureString -String "password" -AsPlainText -Force) -Username<EMAIL_ADDRESS>-Password (Read-Host -AsSecureString -Prompt "Enter password") -LogoFilePath c:\logo.png
```

Creates a new Azure AD Application registration which will use the existing private key certificate at the provided path to allow access. It will upload the provided private key certificate to the azure app registration and it will request the following permissions: Sites.FullControl.All, Group.ReadWrite.All, User.Read.All. It will also set the `logo.png` file as the logo for the Azure AD app.

## PARAMETERS

### -Username
The username to use when logging into the Microsoft Graph. Notice that this user account needs to have write access to the Azure AD

```yaml
Type: String
Parameter Sets: (All)

Required: False
Position: Named
Accept pipeline input: False
```

### -Password
The password to use when logging into the Microsoft Graph

```yaml
Type: String
Parameter Sets: (All)

Required: False
Position: Named
Accept pipeline input: False
```

### -DeviceLogin
If specified, a device login flow, supporting Multi-Factor Authentication will be used to authenticate towards the Microsoft Graph

```yaml
Type: SwitchParameter
Parameter Sets: (All)

Required: False
Position: Named
Accept pipeline input: False
```

### -ApplicationName
The name of the Azure AD Application to create

```yaml
Type: String
Parameter Sets: (All)

Required: True
Position: Named
Accept pipeline input: False
```

### -CertificatePassword
Optional certificate password

```yaml
Type: SecureString
Parameter Sets: (All)

Required: False
Position: 8
Accept pipeline input: False
```

### -CertificatePath
File path to use an existing certificate

```yaml
Type: String
Parameter Sets: Existing Certificate

Required: True
Position: Named
Accept pipeline input: False
```

### -CommonName
Common Name (e.g. server FQDN or YOUR name). defaults to 'pnp.contoso.com'

```yaml
Type: String
Parameter Sets: Generate Certificate

Required: False
Position: 0
Accept pipeline input: False
```

### -Country
Country Name (2 letter code)

```yaml
Type: String
Parameter Sets: Generate Certificate

Required: False
Position: 1
Accept pipeline input: False
```

### -Locality
Locality Name (eg, city)

```yaml
Type: String
Parameter Sets: Generate Certificate

Required: False
Position: 3
Accept pipeline input: False
```

### -Organization
Organization Name (eg, company)

```yaml
Type: String
Parameter Sets: Generate Certificate

Required: False
Position: 4
Accept pipeline input: False
```

### -OrganizationUnit
Organizational Unit Name (eg, section)

```yaml
Type: String
Parameter Sets: Generate Certificate

Required: False
Position: 5
Accept pipeline input: False
```

### -OutPath
Folder to create certificate files in (.CER and .PFX)

```yaml
Type: String
Parameter Sets: Generate Certificate

Required: False
Position: Named
Accept pipeline input: False
```

### -GraphApplicationPermissions
Specify which Microsoft Graph Application permissions to request.

```yaml
Type: Permission[]
Parameter Sets: Generate Certificate

Required: False
Position: 0
Accept pipeline input: False
```

### -GraphDelegatePermissions
Specify which Microsoft Graph Delegate permissions to request.

```yaml
Type: Permission[]
Parameter Sets: Generate Certificate

Required: False
Position: 0
Accept pipeline input: False
```

### -SharePointApplicationPermissions
Specify which Microsoft SharePoint Application permissions to request.

```yaml
Type: Permission[]
Parameter Sets: Generate Certificate

Required: False
Position: 0
Accept pipeline input: False
```

### -SharePointDelegatePermissions
Specify which Microsoft SharePoint Delegate permissions to request.

```yaml
Type: Permission[]
Parameter Sets: Generate Certificate

Required: False
Position: 0
Accept pipeline input: False
```

### -State
State or Province Name (full name)

```yaml
Type: String
Parameter Sets: Generate Certificate

Required: False
Position: 2
Accept pipeline input: False
```

### -Store
Local Certificate Store to add the certificate to. Only works on Microsoft Windows.

```yaml
Type: StoreLocation
Parameter Sets: Generate Certificate

Required: False
Position: Named
Accept pipeline input: False
```

### -Tenant
The identifier of your tenant, e.g. mytenant.onmicrosoft.com

```yaml
Type: String
Parameter Sets: (All)

Required: True
Position: Named
Accept pipeline input: False
```

### -ValidYears
Number of years until expiration (default is 10, max is 30)

```yaml
Type: Int
Parameter Sets: Generate Certificate

Required: False
Position: 7
Accept pipeline input: False
```

### -NoPopup
This switch only applies to Windows and has no effect on Linux and MacOS.

If not specified and running on Windows, all authentication and consent steps will be presented in a popup. If you want to open the URLs manually in a browser, specify this switch.

```yaml
Type: SwitchParameter
Parameter Sets: (All)

Required: False
Position: Named
Accept pipeline input: False
```

### -LogoFilePath

Sets the logo for the Azure AD application. Provide a full path to a local image file on your disk which you want to use as the logo

```yaml
Type: String
Parameter Sets: (All)

Required: False
Position: Named
Accept pipeline input: False
```

## RELATED LINKS

[Microsoft 365 Patterns and Practices](https://aka.ms/m365pnp)

repository: radityoardi/PnP-PowerShell

branch_name: refs/heads/dev

gha_license_id: NOASSERTION

repo_name: radityoardi/PnP-PowerShell


text:
---
layout:       post
title:        "Notes Taking"
date:         2021-06-13 9:00:00
author:       "PC"
header-img:   "img/photo-with-title.png"
header-mask:  0.3
hidden: true
catalog:      true
tags:
    - Notes
---

VPC is kind of being used quite often nowadays. It is easy to have us mixed up with Private Cloud and other Cloud-related terms, so it is great to have a quick summary on the topic and never need to get back and have a look whenever working on a project.

### What is VPC?

 Short for **Virtual Private Cloud**, private sub-section of a cloud server, such as AWS, IBM, GOOGLE, you name it and can place resources with full control and full access permission control. In other words, you rented part of the cloud from your service provider and providing with the space that you own within that cloud server, including the admin rights to control who and how to let in and go out.

### Public Cloud

/*--TODO--*/

### Public Cloud

/*--TODO--*/

### VPC vs Private Cloud

 The most commonly confused term with VPC would be Private Cloud, Private Cloud is usually referring to an enterprise-owned and hosted cloud server and have nothing to do with the public cloud companies (they might work together for a multi-cloud solution, but that is a different story).

### VPC vs Public Cloud

/*--TODO--*/

### Reference
[IBM Explanation of VPC](https://www.ibm.com/cloud/learn/vpc)


text:
PROJECT : Creating a Python Pip Package

Install locally using:

pip install MySam_ML

The objective of this project is to create my own pip package(I have named it as MySam_ML, would use this for further reference)

Advantages of making your own pip package:

You don't want to copy your executable script in every system you need.
You want to make your Python scripts publicly available to everyone and want to help the community.
Sharing scripts between internal teams becomes a lot more hasstle free. You can package all the dependencies together in modules, enhance code reusability, improvise code, update version, and many more.

Getting Started

This is the structure of my basic pip package.

![strucuture](https://user-images.githubusercontent.com/69666263/127244600-d47fbf0d-37b0-41af-a6ae-12383cc44848.png)

The modules under MySam_ML are -
arithmetic.py consisted of 3 functions - sum, sub, multiply
pattern.py had Pattern class which consists of a function named "pypart" that returns a pattern

Here under is a glimpse of PowerShell output, after packing all the modules and dependencies of my package together
![Packaging](https://user-images.githubusercontent.com/69666263/127243574-607b2e63-7a12-43f8-982d-adf0e2f728ba.png)

We can create further sub modules within MySam_ML and have to make sure to include an "__init__.py" file in each of those.
Make sure to pack all the dependencies and functions properly so that it doesn't break.

Generating the fastapi file

FastAPI is a modern, fast (high-performance), web framework for building APIs with Python based on standard Python type hints
The framework is designed to optimize your developer experience so that you can write simple code to build production-ready APIs with best practices by default.

In this project, I have created a basic FastAPI file.

![fastapi 1](https://user-images.githubusercontent.com/69666263/127243711-2b9966ce-480d-4a83-9ea9-37c82d7b8ca9.png)
![fastapi 2](https://user-images.githubusercontent.com/69666263/127243714-a36450e0-94af-4e45-8b01-94246fd40f4e.png)
![fastapi](https://user-images.githubusercontent.com/69666263/127244006-b2cc4f90-ca87-439c-b258-cd748354d4b4.png)

Please, let me know your suggestions/feedbacks/comments on my first pip package. Thank you!

branch_name: refs/heads/main


text:
---
title: MySqlConnection.ProvideClientCertificatesCallback property
---

# MySqlConnection.ProvideClientCertificatesCallback property

Gets or sets the delegate used to provide client certificates for connecting to a server.

```csharp
public Func<X509CertificateCollection, ValueTask>? ProvideClientCertificatesCallback { get; set; }
```

## Remarks

The provided X509CertificateCollection should be filled with the client certificate(s) needed to connect to the server.

## See Also

* class [MySqlConnection](../../MySqlConnectionType/)
* namespace [MySqlConnector](../../MySqlConnectionType/)
* assembly [MySqlConnector](../../../MySqlConnectorAssembly/)

<!-- DO NOT EDIT: generated by xmldocmd for MySqlConnector.dll -->

repository: mysql-net/MySqlConnector

gha_language: C#

gha_license_id: MIT

repo_name: mysql-net/MySqlConnector


text:
# webapp-deployer

A webapp deploy tool that upload files to s3 with meta data

`webapp-deployer` is a tool like aws cli's `s3 sync` command. It uploads files with setting metadata (e.g., `content-type`) along with a config file.

## How it works

`webapp-deployer` first delete all files in the given bucket. After that, it walks through all files under the given webapp directory. If a file matches a pattern, then it does an action. `Upload` action uploads the file. `Exclude` action skip the file. If none of the patterns matches, the file is skipped.

```
% webapp-deployer --help
webapp-deployer 1.0.0
Deploy webapp to s3

USAGE:
    webapp-deployer [FLAGS] <config-file> <app-dir> <bucket-name>

FLAGS:
    -d, --dry-run
    -h, --help       Prints help information
    -V, --version    Prints version information

ARGS:
    <config-file>
    <app-dir>
    <bucket-name>
```

## Config file

A config file is a toml format file, and that is a set of `instruction` for files.

An example instruction looks like as follows:

```toml
[[instructions]]
    pattern = "^static/css/.*\\.css$"
    action = "Upload"
    [instructions.meta]
        content_type = "text/css"
        cache_control = "max-age=31536000"
```

|property |required|description|
|-|-|-|
|pattern|Yes|file path regex pattern|
|action|Yes|Upload or Exclude|
|meta.content_type|No|content-type value|
|meta.cache-control|No|cache-control value|

## Environment variables

`webapp-deployer` takes `AWS_PROFILE` and `AWS_REGION` same as aws cli.

## Usage examples

```
% webapp-deployer --dry-run config.toml ./build my-webapp-bucket
```

```
% AWS_PROFILE=admin AWS_REGION=us-east-1 webapp-deployer config.toml ./build my-webapp-bucket
```

![](docs/screenshot1.png)

gha_language: Rust


text:
### [CVE-2015-3459](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2015-3459)
![](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

The communication module on the Hospira LifeCare PCA Infusion System before 7.0 does not require authentication for root TELNET sessions, which allows remote attackers to modify the pump configuration via unspecified commands.

### POC

#### Reference
- http://hextechsecurity.com/?p=123

#### Github
No PoCs found on GitHub currently.

repository: trickest/cve

gha_language: HTML

repo_name: trickest/cve


text:
# A content downloader

- expects `Object` in the form `{ url: 'https://www.w3schools.com/Xml/cd_catalog.xml' }`
- or `String` with a valid URL `https://www.w3schools.com/Xml/cd_catalog.xml`

repository: totaljs/flowcomponents

gha_language: JavaScript

repo_name: totaljs/flowcomponents


text:
---
layout: default
title: Database Home
parent: TerminusDB Console
grand_parent: User guide
nav_order: 5
---

# Database Home

This Interface shows the home page of a chosen database which displays details related to the database.
A selector is provided where the user can swap between branches of the database. On flicking through these branches the entire state of Database would change.
A history Navigator is a time slider which allows user to navigate through time starting from the date of which the database was created till current time. On sliding through the history navigator the state of the database would change to the chosen date time.

## Details

Shows details of Database and provides you with a table of recent updates

## Manage
In Manage tab, User can also push changes made to the database to Hub. If there's a conflict while merging the database a WOQL Query is automatically generated which fix

## Collaborate
In Collaborate tab, Users are provided with options in which they can invite or add other Hub users to access the current Database. In Order to perform this action the User should be having Manage rights on the database. On having Manage rights User can also assign/ update different capabilities to users.

repository: AndrewO/terminusdb-doc

repo_name: AndrewO/terminusdb-doc


text:
---
layout: layout.pug
navigationTitle:  dcos cluster unlink
title: dcos cluster unlink
menuWeight: 3
excerpt: Unlinking a cluster from another cluster
enterprise: true
render: mustache
model: /mesosphere/dcos/2.1/data.yml
---

# Description
The `dcos cluster unlink` command will unlink the current cluster from one of its linked clusters.

# Usage

```bash
dcos cluster unlink <cluster> [flags]
```
# Options

| Name | Description |
|---------|-------------|
| `-h`, `--help`     |  Displays help for this command. |

## Positional arguments

| Name |  Description |
|---------|-------------|
| `<name>`   | Name of linked cluster (Required) |

If the cluster unlinks successfully there is no output to the console.

# Examples
For examples, see [Cluster Links](/mesosphere/dcos/2.1/administering-clusters/multiple-clusters/cluster-links/).

# Parent command

| Command | Description |
|---------|-------------|
| [dcos cluster](/mesosphere/dcos/2.1/cli/command-reference/dcos-cluster/) | Manage DC/OS clusters. |

repository: mesosphere/dcos-docs-site

gha_language: SCSS

repo_name: mesosphere/dcos-docs-site


text:
---
name: Bug Report
about: Point out a bug in the library.
title: ''
labels: bug
assignees: ''

---

**Describe the Bug**
Please include a clear and concise description of the bug you are noticing.

**To Reproduce**
Please include any relevant steps to reproduce the behaviour leading to the bug you are noticing, e.g.:
1. Go to '...'
2. Click on '....'
3. Scroll down to '....'
4. See error

**Expected behavior**
Please include a clear and concise description of the discrepancy from the expected functionality.

**Screenshots**
If applicable, add screenshots to help explain your problem.

**Desktop (please complete the following information):**
 - OS: [e.g. iOS]
 - Browser [e.g. chrome, safari]
 - Version [e.g. 22]

**Smartphone (please complete the following information):**
 - Device: [e.g. iPhone6]
 - OS: [e.g. iOS8.1]
 - Browser [e.g. stock browser, safari]
 - Version [e.g. 22]

**Additional context**
Add any other context about the problem here.


text:
Jackson module
that adds supports for JDK datatypes included in version 8 which can not be directly
supported by core databind due to baseline being JDK 6, excluding following:

* New Date/Time datatypes (supported by `jackson-datatype-jsr310` module)
* Support for parameter names (supported by `jackson-module-parameter-names`)

## Usage

### Maven dependency

To use module on Maven-based projects, use following dependency:

```xml
<dependency>
  <groupId>com.fasterxml.jackson.datatype</groupId>
  <artifactId>jackson-datatype-jdk8</artifactId>
  <version>2.6.3</version>
</dependency>
```

(or whatever version is most up-to-date at the moment)

### Registering module

Like all standard Jackson modules (libraries that implement Module interface), registration is done as follows:

```java
ObjectMapper mapper = new ObjectMapper();
mapper.registerModule(new Jdk8Module());
// Or, the more fluent version: ObjectMapper mapper = new ObjectMapper().registerModule(new Jdk8Module());
```

after which functionality is available for all normal Jackson operations:
you can read JSON into supported JDK8 types, as well as write values of such types as JSON, so that for example:

```java
class Contact {
    private final String name;
    private final Optional<String> email;

    public Contact(String name, Optional<String> email) {
        this.name = name;
        this.email = email;
    }

    public String getName() {
        return name;
    }

    public Optional<String> getEmail() {
        return email;
    }
}

...

Contact nullEmail = new Contact("Example Co.", null);
String nullEmailJson = mapper.writeValueAsString(nullEmail);
// prints: {"name":"Example Co.","email":null}
System.out.println(nullEmailJson);

Contact emptyEmail = new Contact("Example Co.", Optional.empty());
String emptyEmailJson = mapper.writeValueAsString(emptyEmail);
// prints: {"name":"Example Co.","email":null}
System.out.println(emptyEmailJson);

Contact withEmail = new Contact("Example Co.", Optional.of("info@example.com"));
String withEmailJson = mapper.writeValueAsString(withEmail);
// prints:  {"name":"Example<EMAIL_ADDRESS>System.out.println(withEmailJson);
```

## More

See [Wiki](../../wiki) for more information (javadocs, downloads).

gha_language: Java


text:
# sales_force_train
Apex (SalesForce) training project. The purpose is to understand how to automate and customice SalesForce using APEX with the froce.com plug for Eclipse.

* [Licence](https://github.com/BorisTodorovGichev/sales_force_train/blob/master/LICENSE) - License
* [Force.com](https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/apex_deploying_ide.htm?search_text=ide) - Force.com IDE plugin documentation


text:
# Handwritten Mathematics Recognisers
*Easy and abstracted way to recognise handwritten mathematics in a browser or in a web view.*

The codebase consists of Python and TensorFlow scripts producing trained models used by the recognisers implemented in TypeScript to recognise a digit or an expression handwritten on an HTML canvas. Optionally, the package provides a functionality for a user to handwrite mathematics on a HTML canvas.

*If you wish to contribute or run the development mode see Contribution and Development sections respectively.*

## Usage
To use the package in your NPM based project run `npm install --save handwritten-mathematics-recogniser` it will install the distrubuted version of the package and list it as a dependency for your project.

To recognise a digit handwritten on a canvas:
```
// Import the digit recogniser.
import { HandwrittenDigitRecogniser } from 'handwritten-mathematics-recogniser/digit';

// Import the drawer.
import { Drawer } from 'handwritten-mathematics-recogniser/drawer';

const canvas = document.querySelector('#canvas');
const button = document.querySelector('#button');

// Allow drawing on a canvas.
const drawer = new Drawer(canvas);

// Recognise a digit.
button.addEventListener('click', () => {
  const digit = HandwrittenDigitRecogniser.recognise(canvas);
  console.log(digit);
});
```

To recognise an expression handwritten on a canvas:
```
// Import the expression recogniser.
import { HandwrittenExpressionRecogniser } from 'handwritten-mathematics-recogniser/expression';

// Import the drawer.
import { Drawer } from 'handwritten-mathematics-recogniser/drawer';

const canvas = document.querySelector('#canvas');
const button = document.querySelector('#button');

// Allow drawing on a canvas.
const drawer = new Drawer(canvas);

// Recognise an expression.
button.addEventListener('click', () => {
  const expression = HandwrittenExpressionRecogniser.recognise(canvas);
  console.log(expression);
});
```

## Development
These instructions will get you a copy of the project up and running on your local machine for development and testing purposes. Note that there are two different set of instructions for training and recognition.

### Prerequisites
To run the development mode you will need to install:

**Training**

- [Python](https://www.python.org/) - programming language that lets you work quickly.
and integrate systems more effectively.
- [TensorFlow](https://www.tensorflow.org/) - an open source machine learning framework used to obtained trained model of a neural network.

**Recognition**

- [NodeJS](https://nodejs.org/en/) - programming language that lets you work quickly.
and integrate systems more effectively.
- [NPM](https://www.tensorflow.org/) - node package manager.

### Installing
To develop either a training or recognition part of the package you need to clone the repository or download zipped archive.
```
git clone https://github.com/MaciejCaputa/handwritten-mathematics-recogniser.git
```

**Training**
Source the TensorFlow.
```
source ~/tensorflow/bin/activate
```

Navigate to the location of a training script and run it.
```
python train.py
```

**Recognition**
Navigate into it with a command line and install dependencies.
```
npm install
```

Run the development server which will automatically open your browser showcasing the recognition capability.
```
npm run serve
```

## Public API

`<recogniser>.recognise(HTMLCanvasElement): number`

`new Drawer(HTMLCanvasElement)`

`<recogniser>.recogniseWithMetadata(HTMLCanvasElement): Recognition[]`

## Handwritten Digit Recogniser
Recognises a single digit input with accuracy over 99% on the test data. For recognising multiple digits or more complex expressions use handwritten expression recogniser.

### Dataset
The datased for training and testing of the digit recogniser uses MNIST database of handwritten digits which contains a training set of 60,000 examples, and a test set of 10,000 examples.

### Public API

- `HandwrittenDigitRecogniser` - best-performing-neural-network based recognition (either DNN or CNN)
- `HandwrittenDigitRecogniserDNN` - deep-neural-network based recognition
- `HandwrittenDigitRecogniserCNN` - convolutional-neural-network based recognition

## Handwritten Expression Recogniser
Accurate and time efficient recognition of handwritten mathematical expressions. It recognises:

- classes:
  - digits: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
  - brackets: (, )
  - operations: +, -, ×, ÷, √
  - miscancelous: ., =
- relations:
  - power (superscript)
  - index (subscript)
  - fractions
  - roots

### Public API

- `HandwrittenExpressionRecogniserDNN` - deep-neural-network based recognition (either DNN or CNN)
- `HandwrittenExpressionDigitRecogniserCNN` - convolutional-neural-network based recognition
- `HandwrittenExpressionRecogniser` - best-performing-neural-network based recognition

### Limitations
At this point the recogniser does not supported nested expressions e.g. fraction inside a fraction. Moreover, it requires the handwritten symbols to be explicitly segmentable (two different symbols cannot be connected) and connected (strokes used to handwrite a symbol must intersect).

### Dataset

Dataset used for training and evaluation was extracted from CROHME original dataset. Only 21 classes has been extracted resulting in about 60,000 images and 6000 test data. In comparison each digit in MNIST data set had about 6000 training images whereas in this case each digit received only about 3000. To extend the variety in the dataset images were skewed by no more than 6 degrees in both directions. These resulted in obtaining a dataset to about 180,000 training images.

## Drawer
Provides a functionality to draw on a canvas. To use the recognisers it is not necessary to use the drawing functionality and developers might choose to implement their own solution for drawing.

### Public API

- `new Drawer(HTMLCanvasElement)` - binds to the specified canvas and listens to its touch/click events to provide the drawing feedback to the user.
- `new Drawer(HTMLCanvasElement).clear()` - clears the canvas to which the Drawer is binded to.

## Built With

**Classfication**

- [Python](https://www.python.org/) - programming language that lets you work quickly
and integrate systems more effectively.
- [TensorFlow](https://www.tensorflow.org/) - an open source machine learning framework used to obtained trained model of a neural network.

**Recognition**

- [NodeJS](https://nodejs.org/en/) - a JavaScript runtime built on Chrome's V8 JavaScript engine.
- [TypeScript](https://www.typescriptlang.org/) - a typed subset of JavaScript that compiles to plain JavaScript.

## Contributing

1. Fork it (<https://github.com/MaciejCaputa/handwritten-mathematics-recogniser>).
2. Create your feature branch (`git checkout -b feature/fooBar`).
3. Commit your changes (`git commit -am 'Add some fooBar'`).
4. Push to the branch (`git push origin feature/fooBar`).
5. Create a new Pull Request.

## Acknowledgments

- created as part of the dissertation for BSc Mathematics and Computing at Cardiff University
- supervised by Dr Xianfang Sun and moderated by Dr Frank Langbein
- Copyright (c) 2018 Maciej Caputa All Rights Reserved.

## License

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


text:
# BaseEvent

Vector between two point in 2D space.

## Installation

    npm install @pencil.js/vector

## Examples

```js
import Vector from<EMAIL_ADDRESS>
const vector = new Vector([10, 20], [30, 40]);
vector.length();
```


text:
# Certificate Renewal

To update the client certificate you can use the `renew` command.

```sh
Usage:
  cfn-vpn renew [name]

Options:
  r, [--region=REGION]                           # AWS Region
                                                 # Default: ap-southeast-2
      [--verbose], [--no-verbose]                # set log level to debug
      [--easyrsa-local], [--no-easyrsa-local]    # run the easyrsa executable from your local rather than from docker
      [--certificate-expiry=CERTIFICATE_EXPIRY]  # value in days for when the server certificates expire, defaults to 825 days
      [--rebuild], [--no-rebuild]                # generates new certificates from the existing CA for certiciate type VPNs
      [--bucket=BUCKET]                          # s3 bucket, if not set one will be generated for you
```

## Certificate Authenticated VPN

When renewing the server and client certificates for the Client VPN there are 2 options [renew](#renew) or [rebuild](#rebuild).

In both cases the Client VPN is recreated along with a new vpn endpoint which means once the update is complete each client must [update their config](#updating-client-config) to point to the new VPN endpoint.

The Update process can take as long as 1-2 hours.

### renew

This is the default option and should be used

```sh
cfn-vpn renew [name] --bucket [s3-bucket]
```

### rebuild

This creates new certificates and should only be used if renew doesn't work.

```sh
cfn-vpn renew [name] --bucket [s3-bucket] --rebuild
```

### Updating Client Config

Once the VPN has been updated you will need to retrieve the new vpn endpoint such as

```
*.cvpn-endpoint-<id>.prod.clientvpn.<aws-region>.amazonaws.com
```

Replace the endpoint value in each of the clients opvn configs and reimport them into the vpn client.

```
remote kdipkcte.cvpn-endpoint-<replace-id>.prod.clientvpn.<aws-region>.amazonaws.com 443
```

## VPNs Using Federated Access

run the renew command with the default options

```sh
cfn-vpn renew [name] --bucket [s3-bucket]
```

This will recreate the vpn with the updated server certificate.

This process can take 1-2 hours.

Once complete users will need to log into the self service portal and download new copies of the client config and import them into their vpn client.

gha_language: Ruby


text:
# Quickstart

## Creating An Engine

Now that we have all the conceptual and theoretical talk out of the way, let's actually make an Engine!

As discussed previously, Engines are distributed as Addons and In-Repo-Addons.

## Create as In-Repo-Engine

To create an engine within an existing application's project, run the
`in-repo-engine` generator:

```shell
ember g in-repo-engine <engine-name>
```
> Note: In-repo addons currently are created in the `/lib` directory (e.g. `/lib/my-addon`). Unit tests and integration tests are currently co-mingled with tests for the main application. A separate repo should be used for your engine if you wish to avoid this co-mingling.

So, if we name our Engine `super-blog`, we just do the following:

```shell
ember g in-repo-engine super-blog
```

This has added a directory named `lib` and an app addon directory structure named for `super-blog`.

Using the blueprint in-repo-engine, ember-cli has added all the appropriate files to create a new app structure.

If you want to share elements between an in-repo engine and application, you could do so with an in-repo addon. For example, the following in-repo engine's package (`lib/super-blog/package.json`) references the `common` in-repo addon:

```json
{
  "name": "super-blog",

  "dependencies": {
    "ember-cli-htmlbars": "*",
    "ember-cli-babel": "*"
  },

  "ember-addon": {
    "paths": [
      "../common"
    ]
  }
}
```

### Generate in an In-Repo-Engine

Using the right flags, generating routes, components (etc) in an in-repo engine is the same as in a regular Ember application.

To create a route within an in-repo-engine, you can run:
```shell
ember generate route <route-name> --in-repo <in-repo-name>
```

To create a component within an in-repo-engine, you can run:
```shell
ember generate component <component-name> --in-repo <in-repo-name>
```

To generate helpers, controllers and other things, you can use the `--in-repo` flag like above.

### Using the --in flag
As of<EMAIL_ADDRESS>and higher the generate command includes an `--in` flag that allows you to specify the directory to generate into.
For example, given an in-repo addon at lib/my-foo/:
```shell
ember generate component awesome-sauce --in ./lib/foo
```
Will generate the following files:
```shell
lib/foo/addon/components/awesome-sauce.js
lib/foo/addon/templates/components/awesome-sauce.hbs
tests/integration/components/awesome-sauce-test.js
```
### Remove from In-Repo-Engine
For removing the above generated routes (components and other things) from your engine, replace `generate` with `destroy` in the shell command

Removing a route from an in-repo engine:
```shell
ember destroy route <route-name> --in-repo <in-repo-name>
```

Removing a component from an in-repo engine:
```shell
ember destroy component <component-name> --in-repo <in-repo-name>
```

## Create as Addon

Separate addon projects can be created with the addon command:

```shell
ember addon <engine-name>
```

So, if we name our Engine `super-blog`, we just do the following:

```shell
ember addon super-blog
```

Using a vanilla addon we still need turn it into an engine, follow the steps below.

### Install Engine Dependencies

At this point, you have a vanilla Addon which is not yet an Engine, so let's introduce the remaining pieces needed for it to function as one.

First, we need to install the `ember-engines` addon, which provides support for all the Engines features which haven't been accepted into Ember core yet. Installation is as simple as:

```shell
cd super-blog/
ember install ember-engines
```

A quick note, Engines should have `ember-engines` listed as a `devDependency` and `peerDependency`. The reason for this is that if you include `ember-engines` as a `dependency` of both the host application and the Engine, you'll wind up duplicating some crucial functionality which can cause problems. Therefore, it is best that the host application provide the copy to be used.

Finally, we need to ensure `ember-cli-htmlbars` is listed as a dependency for compiling our templates:

```json
// package.json
"dependencies": {
  "ember-cli-htmlbars": "^1.1.0"
}
```

Pretty simple so far. At this point, we have everything needed to actually create an Engine, but we don't have an Engine itself.

### Configuring your Engine

Within your Engine's root directory, modify `index.js` so that your addon is configured as an Engine using the `buildEngine` function:

```js
// index.js

const { buildEngine } = require('ember-engines/lib/engine-addon');

module.exports = buildEngine({
  name: 'super-blog',
  lazyLoading: {
    enabled: false
  }
});
```

We'll leave the `lazyLoading.enabled` flag as `false` for now, as we'll be discussing the topic of lazy-loading engines in depth later on in this guide.

Within your Engine's `config` directory, modify the `environment.js` file:

```js
// config/environment.js

'use strict';

module.exports = function(environment) {
  const ENV = {
    modulePrefix: 'super-blog',
    environment: environment
  }

  return ENV;
};
```

Finally, to make this addon an actual Engine, create a `engine.js` file under the `addon` directory:

```shell
touch addon/engine.js
```

The `engine.js` file lives inside the `addon` directory because we want it to be within the Addon's/Engine's namespace. We'll explore this idea more later, but it is important to note for now.

Next, add the following code to `engine.js`:

```js
// addon/engine.js
import Engine from '@ember/engine';

import loadInitializers from 'ember-load-initializers';
import Resolver from 'ember-resolver';

import config from './config/environment';

const { modulePrefix } = config;

export default class YourEngine extends Engine {
  modulePrefix = modulePrefix;
  Resolver = Resolver;
}

loadInitializers(YourEngine, modulePrefix);
```

This code will look familiar to anyone that's seen an Ember Application's `app.js` file before. Since Engines are so closely related to Applications, it makes sense that their initial files look similar.

There are four important points from the `engine.js` file:

1. **`config`**: Each Engine has its own configuration file, similar to the one Ember Applications normally have. It's even found in the same location - `config/environment.js`
2. **`Resolver`**: Engines have their own Resolver. This means they look things up independently of their host application.
3. **`modulePrefix`**: Since Engines have their own Resolver, they also must have their own `modulePrefix` to define which modules belong to their namespace. Since the `config` is empty by default, you'll want to add this to your `config/environment.js` file.
4. **`loadInitializers`**: Again, since Engines have their own Resolver and thus their own Container, we want to make sure we run initializers against the Engine on boot-up so they can perform tasks like injections.

---

### **Aside**: App Vs Addon Namespace

Let's take a moment to talk about namespaces.

Every Ember Application has a namespace defined by its `modulePrefix` value. This namespace allows your `Resolver` to find the modules created by Ember-CLI at runtime. You'll likely have noticed before that if you try to import a module that is in your `app` directory, then you need to use the `modulePrefix` instead.

So, if you have the file `app/components/foo-bar.js` and the `modulePrefix` `baz`, you'll have to look it up using `baz/components/foo-bar`.

Similarly, Addons, and therefore Engines, have their own namespace defined by their `name` value in their `index.js`. Anything in the `addon` directory, gets put into the Addon's namespace. Having a separate namespace is one of the primary ways
Engines achieve code isolation.

As long as the `modulePrefix` for your application doesn't match the `name` of an Addon, then your application won't be able to resolve modules living in your Addon. This is why it is important that Engines have their own `Resolver` with a separate `modulePrefix` that matches the Addon's `name`.

Observant developers might also note that Addon's have an `app` directory in addition to their `addon` directory. The `app` directory from an Addon gets merged into the host's namespace. This allows Addons to "re-export" modules from their own namespace into the namespace of the consumer so that they can be used as if part of the host. Engines, however, should never re-export modules into their host, and so anything placed into the `app` directory of an Engine Addon will not be included in the build.

---

## Adding Routes for Routable Engines

At this point, if you're building a Route-less Engine, then you're done and can skip ahead to the "[Mounting An Engine](#mounting-an-engine)" section. If, however, you're building a Routable Engine, then you need to create one more file:

```shell
touch addon/routes.js
```

The `routes.js` file defines the route map for a routable Engine. The contents are fairly simple:

```js
import buildRoutes from 'ember-engines/routes';

export default buildRoutes(function() {
  // route map
});
```

The callback passed to `buildRoutes` functions the same way as [`Router#map`](https://api.emberjs.com/ember/release/classes/EmberRouter) does in a normal application. This means, the `routes.js` file for our `super-blog` might look something like:

```js
import buildRoutes from 'ember-engines/routes';

export default buildRoutes(function() {
  this.route('new');

  this.route('post', { path: 'post/:id' }, function() {
    this.route('comments', function() {
      this.route('comment', { path: ':id' });
    });
  });
});
```

## Mounting An Engine

Now that we have our Engine created, we need to "mount" it in our application so that we can use it. First, however, we should probably talk about templates and top-level routes.

### Engine Templates & Top-Level Routes

In order to actually verify that our Engine renders properly, we need to add a template.

```shell
mkdir addon/templates
touch addon/templates/application.hbs
```

Note that the template we added is called `application`. This is because the top-level route and template in an Engine are known as `application`, similar to what happens with the top-level in a normal application.

This means that from within an Engine, if you want to transition to the first route, you would use `application` as the name instead of the location that the host application knows about.

Anyway, let's add something super simple to our template:

```hbs
<h3>Hello World!</h3>
```

Now we'll be able to verify that our Engine renders when we mount it.

### Loading phases

Engines can exist in several phases:

 **Booted** - an engine that's been installed in a parent application will have its dependencies loaded and its (non-instance) initializers invoked when the parent application boots.

 **Mounted** - Routable and route-less engines have slightly different concepts of "mounting". A routable engine is considered mounted when it has been included by a router at one or more mount-points. A route-less engine is considered mounted as soon as a route's `mount` call resolves.

 **Instantiated** - When an engine is instantiated, an `EngineInstance` is created and an engine's instance initializers are invoked. A routable engine is instantiated when a route is visited at or beyond its mount-point. A route-less engine is instantiated as soon as it is mounted.

Special `before` and `after` hooks could be added to application instance initializers that allow them to be ordered relative to engine instance [initializers](https://guides.emberjs.com/release/applications/initializers/).

### Routable Engines

The technique to mount an Engine into your application varies by the type of Engine you're using. We'll cover routable Engines first.

Mounting a Routable Engine is done through the consumer's `Router` map, like so:

```js
Router.map(function() {
  this.mount('super-blog');
});
```

Pretty straightforward. The `mount` method is very similar to the `route` method you would normally use to define routes. You can specify a `path` and `resetNamespace` options like you normally would:

```js
Router.map(function() {
  this.mount('super-blog', { resetNamespace: true, path: '/blog' });
});
```

You can also specify a special property, `as`, which allows you to mount more than one instance of an Engine by specifying the route name it'll live under:

```js
Router.map(function() {
  this.mount('super-blog', { path: '/blog' });
  this.mount('super-blog', { as: 'dev-blog', path: '/dev-blog' });
});
```

This means that if you transitioned to `super-blog`, you'll land on `/blog`, but if you transition to `dev-blog`, you'll land on `/dev-blog`.

Other than `as`, the key difference between `mount` and `route` is how you specify child routes. For `route` you would normally pass a callback function as an additional argument. With Engines, though, we want our routing structure to be isolated from the host application, and so child routes are defined in the Engines `routes.js` file discussed in the previous section.

Thus, when using `this.mount`, the `buildRoutes` function exported from `routes.js` gets used as the callback you would normally pass to `this.route`.

That about covers it for routable Engines, let's talk about route-less Engines now.

### Route-less Engines

Route-less Engines are much more straightforward to mount in an application.

To mount a route-less Engine, you use the `{{mount}}` keyword in any of your templates:

```hbs
{{mount "super-blog"}}
```

And that's it! The Engine's `application.hbs` will be rendered into the DOM at the mount location.

Prior to Ember 2.16, the `{{mount}}` helper only accepts an Engine's name, no other variables are supported. As of Ember 2.16 a `model` argument can be used to pass state and/or context directly to an engine. An inline `hash` can even be used to pass components via `model`. For more information, please see [the documentation](https://www.emberjs.com/api/ember/3.7/classes/Ember.Templates.helpers/methods/mount?anchor=mount) for this helper.


text:
SA-POSTGRES-WORKPLACE
=====================

[![Build Status](https://travis-ci.org/softasap/sa-postgres-workplace.svg?branch=master)](https://travis-ci.org/softasap/sa-postgres-workplace)

You have possibility to color output with native psql tool with `option_grcat_coloring` or use more sophisticated tool pgcli with `option_pgcli`,
but you would need python and pip on a host.

Possible overrides:

```YAML

option_install_psql: true  # install client tools
postgresql_version: 9.6    # for postgres 9.6
option_install_python: true
option_grcat_coloring: true
option_pgcli: true

```

Example of use: [https://github.com/Voronenko/devops-ruby-app-demo](https://github.com/Voronenko/devops-ruby-app-demo)

Simple:

```YAML

     - {
         role: "sa-postgres-workplace"
       }

```

Advanced:

```YAML

     - {
         role: "sa-postgres-workplace",
         option_install_psql: true,  # install client tools
         postgresql_version: 9.6,    # for postgres 9.6
         option_install_python: true,
         option_grcat_coloring: true,
         option_pgcli: true

       }

```

usage with ansible-galaxy workflow
----------------------------------

If you installed the `sa-postgres-workplace` role using the command

`
   ansible-galaxy install softasap.sa-postgres-workoplace
`

the role will be available in the folder `library/softasap.sa-postgres-workplace`
Please adjust the path accordingly.

```YAML

     - {
         role: "softasap.sa-postgres-workplace"
       }

```

Copyright and license
---------------------

Code is dual licensed under the [BSD 3 clause] (https://opensource.org/licenses/BSD-3-Clause) and the [MIT License] (http://opensource.org/licenses/MIT). Choose the one that suits you best.

Reach us:

Subscribe for roles updates at [FB] (https://www.facebook.com/SoftAsap/)

Join gitter discussion channel at [Gitter](https://gitter.im/softasap)

Discover other roles at  http://www.softasap.com/roles/registry_generated.html

visit our blog at http://www.softasap.com/blog/archive.html

repository: softasap/sa-postgres-workplace

repo_name: softasap/sa-postgres-workplace


text:
---
title: KhaShmup
---
# KhaShmup

<iframe :src="$withBase('/builds/khashmup/index.html')" width="800" height="600" frameBorder="0" style="width: 100vw; height:75vw; max-width:100%; max-height:600px"></iframe>
KhaShmup
====

This example it's an adaptation of the [Jamiltron's KhaShmup](https://github.com/jamiltron/KhaShmup/tree/master) which is the one of the first and the best tutorials about kha online.

In this examples we're using an Entity-Component-System architecutre using some systems and components included in the framework and others created for this example to make a simple Shoot'em up.

[Source Code](https://github.com/Nazariglez/Gecko2D/tree/master/examples/khashmup)


text:
# VFS Team Offboarding Checklist — WORK IN PROGRESS

_Drafted 11/25/19 by Megan Kelley, needs to be reviewed and updated_

## Access Management

_If you are a team building on VA.gov and have questions or need support with access management offboarding, please reach out to VSP Ops_

## Documentation

Before a platform customer departs, the following artifacts should be in place in the relevant team and product folders. This documentation ensures that a future team building on VA.gov can continue building and iterating on the same or similar product.

_If you are a team building on VA.gov and have questions or need support with documentation offboarding, please reach out to VSP’s Content & IA team @Matt Johnson @Megan Kelley @Mikki Northuis_

### Documentation Offboarding and Transition Readiness Checklist

_The following documentation should be saved in the public `va.gov-team` GitHub repository._

**Product Outlines for all products worked on by the team, including:** [See template.](https://github.com/department-of-veterans-affairs/va.gov-team/blob/master/platform/product-management/product-outline-template.md)

* [ ] DEPO point of contact
* [ ] Team member point of contact
* [ ] VA business point of contact, if applicable
* [ ] Narrative/decisions _Description of why this item is the way it is today — past decisions, iterations, prioritizations, pivots, limitations etc._
* [ ] Current status _Description of current state of the item — its core features, MVP/ V1/V2, etc._
* [ ] KPIs or other success metrics
* [ ] Keywords
* [ ] Instructions for how to access
* [ ] User guides/instructions for how to use the product, if applicable
* [ ] Summary of research findings and link to research and discovery docs, if applicable
* [ ] Link to error handling details, if applicable _Including error codes, validations, and user-facing error messages._
* [ ] Link to PagerDuty alert thresholds, if applicable
* [ ] Link to documentation of dependent systems \(such as API calls\), if applicable _The APIs that a product relies upon to function and the calls and responses it makes to function as intended are documented and linked to._

**Nice-to-have documentation**

* [ ] Product flow map _A document showing each step in the flow, what the user is doing at that point, and what's happening technically at that point_
* [ ] S1 bugs, if applicable _GitHub issues with the item's label are open with S1, S2, and S3 bug labels_
* [ ] Product backlog _Some kind of document or GitHub issues backlog exists with potential next steps or future work for the item_


text:
# CS-6350-Machine-Learning
This is a repository to record my assignments in CS6350 Machine Learning class

# Decision Tree

This decision tree implementation is based on the ID3 algorithm.

This tree is without any pruning, only have a parameter to limit the depth of the tree.

# Perceptron

This perceptron is implemented based on the 3 different perceptron algorithm:

1. Standard Perceptron
2. Margin Perceptron
3. Aggressive Perceptron

This implementation also include a simple ``draw.py`` script which is used to draw figures of different parameters.

# SVM

This SVM model is based on sub-gradient algorithm.

# TODO

1. Visualize the decision tree in the browser.


text:
# TOKIO Automated Benchmark Collection Utilities (tokio-abcutils)

## Setting Up

### Step 1. Prepare the working environment

We assume that all of the TOKIO-ABC results are stored in a subdirectory of this
repository called `results`:

    $ mkdir results
    $ cd results
    $ for i in /global/project/projectdirs/m888/glock/tokio-abc-results/runs.{cori,edison}.2017-*; do ln -vs $i;done

In order for the concurrent jobs metrics to be populated, you must define the
following environment variables:

    export NERSC_JOBSDB_HOST="..."
    export NERSC_JOBSDB_USER="..."
    export NERSC_JOBSDB_PASSWORD="..."
    export NERSC_JOBSDB_DB="..."

See a NERSC staff member for the correct values to gain access to the NERSC
jobs database.

### Step 2. Generate job summary files

Then we generate summary json files for each Darshan log.  This takes a
significant amount of time because it involves opening every Darshan log, then
collecting metrics from across the system that correspond to that job.  To do
this in parallel, use the included `parallel_summarize_job.sh` script, e.g.,

    $ ./parallel_summarize_job.sh edison 2>&1 | tee -a summarize_jobs-edison.log
    mkdir: created directory '/global/project/projectdirs/m888/glock/tokio-year/summaries/edison'
    Generating /global/project/projectdirs/m888/glock/tokio-year/summaries/edison/glock_ior_id3906633_2-14-63024-14939811182217632593_1.json
    Generating /global/project/projectdirs/m888/glock/tokio-year/summaries/edison/glock_ior_id4048967_2-19-64883-9509271909828150823_1.json
    Generating /global/project/projectdirs/m888/glock/tokio-year/summaries/edison/glock_ior_id4015752_2-18-63772-1376825852187540237_1.json
    ...

This script is just a parallel wrapper around `summarize_job.py` and is invoked
on each darshan log with options similar to the following:

    $ ./pytokio/bin/summarize_job.py --jobhost=cori \
                                     --concurrentjobs \
                                     --topology=data/cori.xtdb2proc.gz \
                                     --ost \
                                     --json \
                                     results/runs.cori.2017-12/runs.cori.2017-12-31.5/glock_dbscan_*.darshan

This `summarize_job.py` script retrieves and indexes data from each connector,
but it does not strive to synthesize cross-connector metrics such as coverage
factors.  That occurs in analysis that we will perform later on.

### Step 3. Collate job summaries

We then convert the collection of per-job summary json files into a normalized
collection of records in CSV format.

    $ ./normalize_job_summaries.py --output summaries/edison-summaries_%s.csv ./summaries/edison/*.json

The `normalize_job_summaries.py` script takes any number of json files generated
by `summarize_job.py`, finds all of the fields that were populated, and creates
a Pandas DataFrame from all of those records.  Each record that is missing one
or more keys from `summarize_job.py` simply has that field left as a NaN.

The `--output` argument allows you to specify a file name to which the
normalized data should be written in CSV format.  If the `--output` file name
contains a `%s`, this is replaced by the date range represented in the
normalized data.

repository: NERSC/tokio-abcutils

repo_name: NERSC/tokio-abcutils


text:
---
title: 'Exporting all of the Architect flows in your organization'
date: 2021-11-09
tags: cli, Archy, developer engagement, experimental, transform, data, go, templates
author: john.carnell
image: ./blog-img.png
category: 6
---

Greetings everyone. 2021 is almost done and 2022 is quickly approaching. Back in September, Prince Merzula wrote a [blog post](/blog/2021-09-15-archy-export-feature/) introducing how to use [Archy](/devapps/archy/), the Genesys Cloud Command Line Interface (CLI) for exporting and importing Architect flows. The Archy CLI is a powerful tool for managing flows, but it only allows you to manage a single flow at a time. As I have begun working this last quarter on building out CI/CD pipelines using [CX as Code](/api/rest/CX-as-Code/) I have often run into situations where I need to export all of the Architect flows in an organization so I can put the flows under source control management. While Archy allows you to export individual flows, it does not allow me to easily do this in "bulk".

Fortunately, I can accomplish this using a combination of the Archy CLI and the new **transform** feature in the Genesys Cloud CLI. Michael Roddy first introduced this feature in a [blog post](/blog/2021-10-01-experimental-feature-transform-data/) in early October. The Genesys Cloud CLI **transform** feature allows us to write a [GO templating language](https://pkg.go.dev/text/template) file that can be used to transform the data from the JSON output returned by the Genesys Cloud CLI into any format you want. Since the **transform** feature leverages a full templating language we can leverage conditional and looping constructs along with a number of helper functions using the [Sprig](http://masterminds.github.io/sprig/) library.

Using this feature, I can write a small template that will take the output from a `gc flows list -a` command to generate a set of `archy export` commands that can then be used to execute a series of Archy exports.

## Writing the transform

When we use the Genesys Cloud CLI command, `gc flows list -a`, we return a list of all the flows currently under management within a Genesys Cloud organization. For the purposes of this blog post, the output from the `gc flows list -a` command against my demonstration organization looks like this:

```json
[
  {
    "id": "037f2416-0bfc-4172-afe1-18a8989cae7e",
    "name": "Default In-Queue Flow",
    "division": {
      "id": "e2220f18-f824-4ade-adf8-7375c04e5eb6",
      "name": "Home",
      "selfUri": "/api/v2/authorization/divisions/e2220f18-f824-4ade-adf8-7375c04e5eb6"
    },
    "description": "This flow provides handling for calls waiting in a queue.",
    "type": "INQUEUECALL",
    "active": false,
    "system": true,
    "deleted": false,
    "checkedInVersion": {
      "id": "1.0",
      "name": "1.0",
      "commitVersion": "1.0",
      "configurationVersion": "1.0",
      "secure": false,
      "configurationUri": "/api/v2/flows/037f2416-0bfc-4172-afe1-18a8989cae7e/versions/1.0/configuration",
      "selfUri": "/api/v2/flows/037f2416-0bfc-4172-afe1-18a8989cae7e/versions/1.0"
    },
    "currentOperation": {
      "id": "9fa478a0-9e34-4b40-9753-951a443daf60",
      "complete": true,
      "client": {
        "id": "3dfb45d2-acbd-4709-a652-4114f1d782b8",
        "name": "CX as Code",
        "selfUri": "/api/v2/oauth/clients/3dfb45d2-acbd-4709-a652-4114f1d782b8"
      },
      "errorDetails": [],
      "actionName": "VALIDATE",
      "actionStatus": "SUCCESS"
    },
    "selfUri": "/api/v2/flows/037f2416-0bfc-4172-afe1-18a8989cae7e"
  },
  ...  //Shortened for conciseness
]
```

While I am only showing one Architect flow in the above code snippet, there are 4 Architect flows in the actual payload returned for my organization. For the transform we are going to need to pull the `name` of the flow and the `type` of the flow out of the JSON being returned and inject it into an Archy command. When all is said and done, I should have 4 `archy export` commands being created. The transform is shown below:

```go
{{- range . -}}{{printf "archy export --flowName \"%s\" --flowType %s --exportType yaml --outputDir output --force\n" .name (lower .type)}}{{end}}
```

There are a fews things to note here. First, all of the data injected into this call is an array of records. Each record is a map of key/value pairs representing the JSON data being returned from the CLI. Embedded JSON objects in the payload are represented as a combination of arrays and maps. Second, to walk through each record we are going to use the `range` keyword. Then we are going to use the `printf` function to build a string containing each `archy export` command. Each value to be injected is going to be done via a `%s` placeholder.  The `flowName` and `flowType` command line parameters are injected by using the `.name` and `.type` values. The `.` allows us to access the current record being looped over by the `range` command. Since the `flowType` value is always lowercased, but stored in the backend as uppercase, I use the Sprig function `lower` to convert `.type` value to lowercase.

:::{"alert":"warning","title":"A word on flowType","autoCollapse":false}
One thing to be aware of is that it is possible to have different types of Architect flows with the exact same name. This is one of the reasons why the `flowType` variable is a required on an `archy export`. If you do have multiple flows with the same name, first consider renaming the flows. If that is not option, you might need to be build multiple transform files specific to each flow type and process each flow type independently going to their own `outputDir`. The reason for this is that the `archy export` currently does not allow you to specify the name of the outputted file being created. Multiple flow types with the same name would create a situation where the `archy export` commands would end up overwriting the previous file of a different type.
:::

## Executing the transform

Let's put the transform shown above into a file called `archy_export_all.tmpl` and use it in our `gc flows list` command.

`gc flows list -a -transform archy_export_all_tmpl`

The output from this command, as run against my Genesys Cloud organization, looks like this:

```shell
archy export --flowName "Default In-Queue Flow" --flowType inqueuecall --exportType yaml --outputDir output --force
archy export --flowName "trsy" --flowType inboundcall --exportType yaml --outputDir output --force
archy export --flowName "SimpleFinancialIvr" --flowType inboundcall --exportType yaml --outputDir output --force
archy export --flowName "EmailAWSComprehendFlow" --flowType inboundemail --exportType yaml --outputDir output --force
```

You can redirect this output to a shell (or bat file for windows):

`gc flows list -a -transform archy_export_all_tmpl > export_architect_flows.sh`

Once the `archy export` commands are exported to a file you can execute the file to carry out the export of the Architect flows:

`./export_architect_flows.sh`

## Final Thoughts

Using the technique above you could easily write a nightly job to export all of your flows to the filesystem and then check them into source control. It is definitely not the most elegant code in the world, but system administration on any platform is a represents a constant tension between elegance and pragmatism. The **transform** feature is incredibly useful when you have to take the data from Genesys Cloud and "mash" into another format. Remember, the outputted format does not have to just be data, but also commands you could execute against other systems and platforms.

## Additional Resources

1. [Introducing the Archy export feature](/blog/2021-09-15-archy-export-feature/)
2. [Archy](/devapps/archy/)
2. [CX as Code](/api/rest/CX-as-Code/)
3. [The Genesys Cloud CLI transform feature](/blog/2021-10-01-experimental-feature-transform-data/)
4. [Golang Templating Language](https://pkg.go.dev/text/template)
5. [Sprig Templating Library](http://masterminds.github.io/sprig/)
6. [DevDrop - Exporting Architect flows](https://youtu.be/QAmkM_agsrY)
7. [DevDrop - Using the CLI Transform function](https://youtu.be/XLn5lIV6POY)

repository: MyPureCloud/developer-center-blog

gha_language: HCL

repo_name: MyPureCloud/developer-center-blog


text:
# Renature Documentation Site

Now built with react-static!

## Getting Started

To install and run the docs site locally:

```sh
$ cd docs
$ yarn install
$ yarn start
```

Then visit: http://localhost:3000/open-source/renature/

## Building the site for deployment

### Build and check the production site

The staging and production sites are served from a nested path, e.g. `https://formidable.com/open-source/renature`.

```sh
$ cd docs
$ yarn build
$ yarn serve
```

Then visit: http://localhost:4000/open-source/renature/

Both of these steps are important for validating that both the `basePath` used by the static HTML output and the `basename` used
by the client-side router are working as expected. This is also where you'll want to validate that there are no hardcoded, inlined, or malformed asset paths that worked locally but will not resolve correctly in production!

## Deployment

### Staging

_Only for project administrators._

Our CI deploys to staging for each PR using surge.sh at the following URL:

`https://formidable-com-renature-staging-${PR_NUMBER}.surge.sh/open-source/renature`

To test things out locally find the `Surge.sh` entry in 1password in the IC vault and make up some pretend values for a PR number in `FORMIDEPLOY_PULL_REQUEST`:

```sh
$ cd docs
$ yarn clean && \
  yarn build
$ SURGE_LOGIN=<SNIPPED> \
  SURGE_TOKEN=<SNIPPED> \
  FORMIDEPLOY_PULL_REQUEST=12 \
  yarn deploy:stage
```

### Production

_Only for project administrators._

Our CI is configured to deploy the production build in `dist` to `formidable.com/open-source/renature`. This section discusses kicking the tires locally:

First, install the AWS CLI:

```sh
$ brew install awscli
```

Then, set up `aws-vault` with the AWS access and secret keys for "CI" in the `AWS IAM (renature-ci)` entry in the IC vault:

```sh
$ brew cask install aws-vault
$ aws-vault add fmd-renature-ci
# Enter AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY values.
```

_note_ if these keys do not already exist in the IC vault, they will need to be created. Please reach out to a member of the cloud team for help.

Then build for production and deploy with dry run to check things:

```sh
$ cd docs
$ yarn clean && \
  yarn prod:build
$ aws-vault exec fmd-renature-ci --no-session -- \
  yarn deploy:prod --dryrun
```

## Tips for developing

- Almost all of your code will be executed in two contexts: first in node for server-side rendering and static html generation, then client-side as a PWA. In addition to writing [node-safe code](https://github.com/nozzle/react-static/blob/master/docs/concepts.md#writing-universal-node-safe-code), this also means that it's necessary to validate that both contexts are working as expected.

- In addition to two execution contexts, there are three stages: development, staging, and production. `yarn start` uses a local dev server with live reload that takes about one second to rebuild. This is a good choice for most local development, but it's important to keep in mind that **the development server does not build the static html.** For that, you will want to use `yarn build && yarn serve` used for staging and production deploys.

- When debugging an issue with the static html output, don't be shy about cracking open the `dist` folder and looking at the output!

repository: FormidableLabs/renature

branch_name: refs/heads/saturn

gha_language: TypeScript

repo_name: FormidableLabs/renature


text:
Software Engineering Team3
------------
Team 3 Project for Software Engineering at Missouri State University

Prerequisite(s)
-------------
1. [python](http://www.www.python.org/ "python")
2. [django](http://www.djangoproject.com/ "django")
3. [south](http://south.aeracode.org/ "south")

Download these and install them.

If you are using an Ubuntu based Linux distribution, you can install them via:

**`sudo apt-get install python python-django python-django-south`**

Database Initalization
--------------------
To generate the initial (empty) database, run:

**`python manage.py syncdb`**
**`python manage.py migrate`**

Start the Server
--------------------
To start the server, run:

**`python manage.py runserver <IP_ADDRESS>:8000`**
(Note, you can change 8000 to the port of your choice)

To view the root page, open: http://localhost:8000


text:
# DGL Implementation of the Node2vec
This DGL example implements the graph embedding model proposed in the paper
[node2vec: Scalable Feature Learning for Networks](https://arxiv.org/abs/1607.00653)

The author's codes of implementation is in [Node2vec](https://github.com/aditya-grover/node2vec)

Example implementor
----------------------
This example was implemented by [Smile](https://github.com/Smilexuhc) during his intern work at the AWS Shanghai AI Lab.

The graph dataset used in this example
---------------------------------------

cora
 - NumNodes: 2708
 - NumEdges: 10556

ogbn-products
 - NumNodes: 2449029
 - NumEdges: 61859140

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

- python 3.6+
- Pytorch 1.5.0+
- ogb

 How to run example files
--------------------------------
To train a node2vec model:
```shell script
python main.py --task="train"
```

To time node2vec random walks:
```shell script
python main.py --task="time" --runs=10
```

Performance
-------------------------

**Setting:** `walk_length=50, p=0.25, q=4.0`
| Dataset  |     DGL     |     PyG     |
| -------- | :---------: | :---------: |
| cora     | 0.0092s | 0.0179s |
| products | 66.22s  | 77.65s  |
Note that the number in table are the average results of multiple trials.
For cora, we run 50 trials.  For ogbn-products, we run 10 trials.

repository: dmlc/dgl

gha_language: Python

repo_name: dmlc/dgl


text:
### Templates

Template is a quick way to create a chatbot without writing any code. It's necessary to set only some template settings in the portal and your chatbot will be available to be published into any **Blip** channel.

**Important Note:** All chatbot created using template are hosted by Blip.

repository: takenet/blip-docs

repo_name: takenet/blip-docs


text:
## How to Reproduce

### Login

Sign in to [QingCloud Console](https://console.qingcloud.com/) with you own account.

### Create QKE Cluster

You can create QKE cluster according to [QKE User Guide](https://docs.qingcloud.com/product/container/qke/index).

- Choose ap2a/ap3 region, and navigate to QKE cluster

![](guide1.png)

- Create Cluster with standard test resource configuration

![](guide2.png)

![](guide3.png)

![](guide4.png)

![](guide5.png)

- Click the VNC icon to log in to the client node with `root/<clusterID>` password

![](guide6.png)

![](guide7.png)

>> Note:
>> please choose ap2a or ap3 region to avoid network issues when pulling gcr.io images.

### Run conformance tests

- Start the conformance tests on your test host

```shell
sonobuoy run \
  --mode=certified-conformance \
```

You can monitor the conformance tests by tracking the sonobuoy logs. Wait for the line no-exit was specified, sonobuoy is now blocking, which signals the end of the testing.

```shell
sonobuoy logs -f
```

Upon completion of the tests you can obtain the results by copying them off the sonobuoy pod.

```shell
OUTPUT_PATH=$(sonobuoy retrieve)
echo ${OUTPUT_PATH}
mkdir ./results
tar xzf ${OUTPUT_PATH} -C ./results
```


text:
# CoreDNS

CoreDNS is DNS server that started as a fork of [Caddy](https://github.com/mholt/caddy/). It has the
same model: it chains middleware.

CoreDNS is the successor of [SkyDNS](https://github.com/skynetservices/skydns). SkyDNS is a thin
layer that exposes services in etcd in the DNS. CoreDNS builds on this idea and is a generic DNS
server that can talk to multiple backends (etcd, consul, kubernetes, etc.).

CoreDNS aims to be a fast and flexible DNS server. The keyword here is *flexible*, with CoreDNS you
are able to do what you want with your DNS data. And if not: write a middleware!

Currently CoreDNS is able to:

* Serve zone data from a file, both DNSSEC (NSEC only) and DNS is supported (middleware/file).
* Retrieve zone data from primaries, i.e. act as a secondary server (AXFR only) (middleware/secondary).
* Sign zone data on-the-fly (middleware/dnssec).
* Loadbalancing of responses (middleware/loadbalance).
* Allow for zone transfers, i.e. act as a primary server (middleware/file).
* Caching (middleware/cache).
* Health checking (middleware/health).
* Use etcd as a backend, i.e. a 101.5% replacement for
  [SkyDNS](https://github.com/skynetservices/skydns) (middleware/etcd).
* Use k8s (kubernetes) as a backend (middleware/kubernetes).
* Serve as a proxy to forward queries to some other (recursive) nameserver (middleware/proxy).
* Rewrite queries (both qtype, qclass and qname) (middleware/rewrite).
* Provide metrics (by using Prometheus) (middleware/metrics).
* Provide Logging (middleware/log).
* Has support for the CH class: `version.bind` and friends (middleware/chaos).
* Profiling support (middleware/pprof).

## Status

I'm using CoreDNS is my primary, authoritative, nameserver for my domains (`miek.nl`, `atoom.net`
and a few others). CoreDNS should be stable enough to provide you with a good DNS(SEC) service.

There are still few [issues](https://github.com/miekg/coredns/issues), and work is ongoing on making
things fast and reduce the memory usage.

All in all, CoreDNS should be able to provide you with enough functionality to replace parts of
BIND9, Knot, NSD or PowerDNS.
Most documentation is in the source and some blog articles can be [found
here](https://miek.nl/tags/coredns/). If you do want to use CoreDNS in production, please let us
know and how we can help.

<https://caddyserver.com/> is also full of examples on how to structure a Corefile (renamed from
Caddyfile when I forked it).

## Examples

Start a simple proxy:

`Corefile` contains:

~~~ txt
.:1053 {
    proxy . <IP_ADDRESS>:53
}
~~~

Just start CoreDNS: `./coredns`.
And then just query on that port (1053), the query should be forwarded to <IP_ADDRESS> and the response
will be returned.

Serve the (NSEC) DNSSEC signed `miek.nl` on port 1053, errors and logging to stdout. Allow zone
transfers to everybody.

~~~ txt
miek.nl:1053 {
    file /var/lib/bind/miek.nl.signed {
        transfer to *
    }
    errors stdout
    log stdout
}
~~~

Serve `miek.nl` on port 1053, but forward everything that does *not* match `miek.nl` to a recursive
nameserver *and* rewrite ANY queries to HINFO.

~~~ txt
.:1053 {
    rewrite ANY HINFO
    proxy . <IP_ADDRESS>:53

    file /var/lib/bind/miek.nl.signed miek.nl {
        transfer to *
    }
    errors stdout
    log stdout
}
~~~

All the above examples are possible with the *current* CoreDNS.

## What remains to be done

* Website?
* Logo?
* Optimizations.
* Load testing.
* The [issues](https://github.com/miekg/coredns/issues).

## Blog

<https://miek.nl/tags/coredns/>

## Systemd service file

Use this as a systemd service file. It defaults to a coredns wich a homedir of /home/coredns
and the binary lives in /opt/bin:

~~~ txt
[Unit]
Description=CoreDNS DNS server
Documentation=https://miek.nl/tags/coredns
After=network.target

[Service]
PermissionsStartOnly=true
PIDFile=/home/coredns/coredns.pid
LimitNOFILE=8192
User=coredns
WorkingDirectory=/home/coredns
ExecStartPre=/sbin/setcap cap_net_bind_service=+ep /opt/bin/coredns
ExecStart=/opt/bin/coredns -pidfile /home/coredns/coredns.pid -conf=/etc/coredns
ExecReload=/bin/kill -SIGUSR1 $MAINPID
Restart=on-failure

[Install]
WantedBy=multi-user.target
~~~

repository: campbellj-info/coredns

repo_name: campbellj-info/coredns


text:
Ansible Role for Docker
=========

Installs docker on Ubuntu with version pinning support.

Requirements
------------

None.

Role Variables
--------------

Role variables with their defaults:

```yaml
docker_version: "18.06"
docker_apt_key_id: 9DC858229FC7DD38854AE2D88D81803C0EBFCD88
docker_apt_key_url: https://download.docker.com/linux/ubuntu/gpg
docker_users: []
```

The `docker_version` should be the version you want pinned, so a newer version does not automatically get installed when adding a server later or when performing a apt upgrade. The packes `docker-ce` and `docker-ce-cli` will be pinned to the same version.

A more current example:

```yaml
docker_version: "5:19.03"
```

The variable `docker_users` should be a list with one or more users that should be added to the docker group.

```yaml
docker_users:
  - ubuntu
  - vagrant
```

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

None

Example Playbook
----------------

```yaml
- hosts: all
    become: true
    roles:
        - akkerman.docker
```

License
-------

BSD

Author Information
------------------

An optional section for the role authors to include contact information, or a
website (HTML is not allowed).


text:
---
layout: post
title: "A Neural Probabilistic Language Model"
date: 2017-01-26
paper_ref: Bengio, et al., 2003
redirect_from:
     - /paper-summaries/2017/01/26/neural-probabilistic-language.html
---

<script type="text/x-mathjax-config">
MathJax.Hub.Config({
  TeX: { equationNumbers: { autoNumber: "AMS" } },
  tex2jax: {inlineMath: [['$','$'], ['\\(','\\)']]}
});
</script>

<script type="text/javascript" async
  src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-MML-AM_CHTML">
</script>
---

[{{ page.paper_ref }}](http://www.jmlr.org/papers/volume3/bengio03a/bengio03a.pdf)

## Summary

* associate with each word in the vocabulary a distributed *word feature vector* (real valued vector in $\mathbb{R}^n$)
* express the joint probability function of word sequences in terms of the feature vectors of these words in the sequence
* learn simultaneously the word feature vectors and the parameters of that probability function

For discrete random variables, learning a joint probability distribution is hard because a small change in one of the variables could cause a large change in the value of the function to be estimated. Instead, transforming the discrete random variables into a vector space in $\mathbb{R}^n$ allows the use of neural nets or GMMs which are smooth approximators. Additionally, the notion of a "nearby" word within the continuous vector space representation is now defined more clearly.

Words are mapped into a matrix $C$ of size ($\|V\| \times m$) for a vocabulary size $\|V\|$ and embedding dim $m$. The feature vectors (columns of $C$) are learned simultanesouly with the parameters of the neural network. The input to the time-lagged neural network (RNN) is the concatenated vector of word representations. The objective is to maximize the log-likehood of a given sequence of out-of-sample words. This essentially is the encoder in Neural Machine Translation.

## Things of interest

* The curse of dimensionality in modeling joint probability of sequences of words in a language is a major stumbling block
* One can reduce the difficulty by using the fact that temporally closer words in the word sequence are statistically more dependent $\rightarrow$ *n-gram* models
* It was noted by the authors that n-gram models and the neural models made different "errors", so an averaging model of the two showed improvements overall
* It is suggested by the authors as well to train multiple smaller networks on partitions of the training data to speed things up
* Learning word embeddings is very parallelizable- specifically, the computation of the output layer of the neural model was found to take up roughly 99.7% of the computation (since you're computing a likelihood of a sequence out of the entire vocabulary)


text:
Transaction Specification
-------------------------

### Format

Transactions passed to the Ledger device will be in the following format. The Ledger device MUST accept any transaction (valid as below) in this format.

```json
{
  "account_number": {number},
  "chain_id": {string},
  "fee": {
    "amount": [],
    "gas": {number}
  },
  "memo": {string},
  "msgs": [{arbitrary}],
  "sequence": {number}
}
```

`msgs` is a list of messages, which are arbitrary JSON structures. Ledger app currently supports `MsgDeposit` & `MsgSend` (examples below).
**Note:** All amount & gas values must be in base integer unit 1e8. E.g. "1.0" RUNE is invalid. The amount must be "100000000".

#### Examples

```json
{
  "account_number": "588",
  "chain_id": "thorchain",
  "fee": {
    "amount": [],
    "gas": "2000000"
  },
  "memo": "TestMemo",
  "msgs": [
    {
      "type": "thorchain/MsgSend",
      "value": {
        "amount": [
          {
            "amount": "150000000",
            "denom": "rune"
          }
        ],
        "from_address": "tthor1c648xgpter9xffhmcqvs7lzd7hxh0prgv5t5gp",
        "to_address": "tthor10xgrknu44d83qr4s4uw56cqxg0hsev5e68lc9z"
      }
    }
  ],
  "sequence": "5"
}
```

```json
{
  "account_number": "588",
  "chain_id": "thorchain",
  "fee": {
    "amount": [],
    "gas": "10000000"
  },
  "memo": "",
  "msgs": [
    {
      "type": "thorchain/MsgDeposit",
      "value": {
        "coins": [
          {
            "amount": "330000000",
            "asset": "THOR.RUNE"
          }
        ],
        "memo": "SWAP:BNB.BNB:tbnb1qk2m905ypazwfau9cn0qnr4c4yxz63v9u9md20:",
        "signer": "tthor1c648xgpter9xffhmcqvs7lzd7hxh0prgv5t5gp"
      }
    }
  ],
  "sequence": "6"
}
```

#### Display Logic

The Ledger device SHOULD pick a suitable display representation for the transaction.

The key type (secp256k1 / ed25519), `account_number`, `chain_id`, `fee` , `memo`, and `sequence`, should be displayed in that order, each on their own page, autoscrolling if necessary. Some fields may be clipped when not in advanced mode.

`msgs` should be iterated through and each displayed according to the following recursive logic:

```
display (json, level)
  if level == 2
    show value as json-encoded string
  else
    switch typeof(json) {
      case object:
        for (key, value) in object:
          show key
          display(value, level + 1)
      case array:
        for element in array:
          display(element, level + 1)
      otherwise:
        show value as json-encoded string
    }
```

starting at level 0, e.g. `display(msgs[0], 0)`.

### Validation

The Ledger device MUST validate that supplied JSON is valid. Our JSON specification is a subset of [RFC 7159](https://tools.ietf.org/html/rfc7159) - invalid RFC 7159 JSON is invalid Ledger JSON, but not all valid RFC 7159 JSON is valid Ledger JSON.

We add the following two rules:
- No spaces or newlines can be included, other than escaped in strings
- All dictionaries must be serialized in lexicographical key order

This serves to prevent signature compatibility issues among different client libraries.

This is equivalent to the following Python snippet:

```python
import json

def ledger_validate(json_str):
  obj = json.loads(json_str)
  canonical = json.dumps(obj, sort_keys = True, separators = (',', ':'))
  return canonical == json_str

assert ledger_validate('{"a":2,"b":3}')
assert ledger_validate('{"a ":2,"b":3}')
assert not ledger_validate('{"a":2,\n"b":3}')
assert not ledger_validate('{"b":2,"a":3}')
assert not ledger_validate('{"a" : 2 }')
```

repository: cryptobuks/THORChain-ledger-thorchain

repo_name: cryptobuks/THORChain-ledger-thorchain


text:
# app-expensify

A web app to manage expenses, based on a course from [Udemy](https://www.udemy.com/react-2nd-edition/) (React, Redux, Jest, Enzyme, Firebase, Heroku).

## Getting Started

These instructions will get you a copy of the project up and running on your local machine for development and testing purposes.
See deployment for notes on how to deploy the project on a live system.

### Prerequisites

What things you need to install the project:
- [Node](https://nodejs.org/en/)
- [Yarn](https://yarnpkg.com/)
- A [Firebase](https://firebase.google.com/) account
- A [Heroku](https://www.heroku.com/) account with a project

### Installing

```
git clone git@github.com:ferhatsahin/app-expensify.git
cd app-expensify
yarn install
```

#### Firebase configuration

**Database**

[Create](https://console.firebase.google.com/) 2 real time database projects (one for real data, one for unit tests data).

For each of them, in the rules, paste the rules provided in `firebase.database.rules.json`.

You need to create `.env.development` and `.env.test` files with your firebase credentials as follows:

```
// .env.development
FIREBASE_API_KEY=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
FIREBASE_AUTH_DOMAIN=app-name.firebaseapp.com
FIREBASE_DATABASE_URL=https://app-name.firebaseio.com
FIREBASE_PROJECT_ID=app-name
FIREBASE_STORAGE_BUCKET=app-name.appspot.com
FIREBASE_MESSAGING_SENDER_ID=XXXXXXXXXXXX
```
Paste the credentials you get when you click on project parameters (the real database project) then add to your web application.

```
// .env.test
FIREBASE_API_KEY=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
FIREBASE_AUTH_DOMAIN=app-test-name.firebaseapp.com
FIREBASE_DATABASE_URL=https://app-test-name.firebaseio.com
FIREBASE_PROJECT_ID=app-test-name
FIREBASE_STORAGE_BUCKET=app-test-name.appspot.com
FIREBASE_MESSAGING_SENDER_ID=XXXXXXXXXXXX
```
Paste the credentials you get when you click on project parameters (the unit tests database project) then add to your web application.

Never commit these files !

Finally configure rules on your Firebase console as given in `firebase.database.rules.json` for the real production database.

**Authentication**
In your dashboard, authentication part, configure a connection mode to allow Google provider.

#### Heroku configuration
Create an app in your [dashboard account](https://dashboard.heroku.com/) then follow instructions given by Heroku:

```
heroku git:remote -a <your-heroku-app-name>
```

To be sure heroku remotes urls are ok:
```
git remote -v
```

You'll need environment variables in Heroku with your Firebase credentials:

```
heroku config:set FIREBASE_API_KEY=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx FIREBASE_AUTH_DOMAIN=app-test-name.firebaseapp.com FIREBASE_DATABASE_URL=https://app-test-name.firebaseio.com FIREBASE_PROJECT_ID=app-test-name FIREBASE_STORAGE_BUCKET=app-test-name.appspot.com FIREBASE_MESSAGING_SENDER_ID=XXXXXXXXXXXX
```
You can run `heroku config` to check the variables are ok with your own credentials.

## Watching

```
yarn dev-server
```
Open [http://localhost:8080/](http://localhost:8080/) in your browser.

## Running the tests
```
yarn test
```
You could also watch tests while you're working:
```
yarn test -- --watch
```

### Coding style tests

All tests are in `src/tests` with the same architecture that in `src` folders for each file.

## Deployment

It uses Heroku so be sure you're logged in and connect your code to the heroku repo.

```
yarn deploy
```

It opens an url like this: https://your-heroku-app-name.herokuapp.com/

**Last step:**
In your firebase dashboard, you need to authorize your heroku app url in authentication > Connection Mode > Allowed Domains :
add it and it's ok!

repository: ferhatsahin/app-expensify

repo_name: ferhatsahin/app-expensify