text:
# IAP External Identities Support with FirebaseUI

To use external identities with
[IAP](https://cloud.google.com/iap/docs/external-identities), your app needs a
page for authenticating users. IAP will redirect any unauthenticated
requests to this page.

The `FirebaseUiHandler` API in `firebaseui` module provides simple, customizable
elements that help reduce boilerplate code when building the authentication UI.
It handles the UI flows for tenant selection, user authentication,
token refreshes and sign-out.

FirebaseUiHandler implements the
[`AuthenticationHandler`](https://cloud.google.com/iap/docs/create-custom-auth-ui)
interface that
[`gcip-iap`](https://github.com/GoogleCloudPlatform/iap-gcip-web-toolkit)
defines. You just need to provide a UI configuration object and pass it to a
`gcip-iap` Authentication instance.

## Table of Contents

1. [Prerequisite](#Prerequisite)
2. [Installation](#installation)
3. [Configuring your authentication UI](#configuring-your-authentication-ui)
4. [API references](#api-reference)
5. [Configuring Authentication URL](#configuring-authentication-url)

## Prerequisite

A [Google Cloud Identity Platform](https://cloud.google.com/identity-platform/)
project is required. Firebase projects can upgrade to GCIP projects through the
[Cloud Console](https://console.cloud.google.com/customer-identity).

Ensure you've configured IAP to use external identities and set up providers
with Identity Platform. See
[Enabling external identities](https://cloud.google.com/iap/docs/enable-external-identities)
to learn how.

## Installation

Install `gcip-iap`, `firebaseui` and its peer-dependency firebase via npm using
the following commands:

```bash
$ npm install firebase --save
$ npm install firebaseui --save
$ npm install gcip-iap --save
```

The `gcip-iap` module is not available via CDN.

You can then `import` the following modules within your source files:

```javascript
// Import firebase modules.
import firebase from "firebase/compat/app";
import "firebase/compat/auth";
// Import firebaseui module.
import * as firebaseui from 'firebaseui'
// Import gcip-iap module.
import * as ciap from 'gcip-iap';
```

Or use cjs `require` to include the modules:

```javascript
// Require firebase modules.
var firebase = require('firebase/compat/app');
require('firebase/compat/auth');
// Require firebaseui module.
var firebaseui = require('firebaseui');
// Require gcip-iap module.
var ciap = require('gcip-iap');
```

Localization is supported by FirebaseUI. You need to build and import the
localized versions following the
[instructions](https://github.com/firebase/firebaseui-web#building-firebaseui).

## Configuring your authentication UI
`FirebaseUiHandler` takes a configuration object that specifies the tenants and
providers to use for authentication. A full configuration can be very long,
and might look something like this:
```javascript
// The project configurations.
const configs = {
  // Configuration for project identified by API key API_KEY1.
  API_KEY1: {
    authDomain: 'project-id1.firebaseapp.com',
    // Decide whether to ask user for identifier to figure out what tenant to
    // select or whether to present all the tenants to select from.
    displayMode: 'optionFirst', // Or identifierFirst
    callbacks: {
      // The callback to trigger when the selection tenant page
      // or enter email for tenant matching page is shown.
      selectTenantUiShown: () => {
        // Show title and additional display info.
      },
      // The callback to trigger when the selection tenant page
      // or enter email for tenant matching page is hidden.
      selectTenantUiHidden: () => {
        // Hide title and additional display info.
      },
      // The callback to trigger when the sign-in page
      // is shown.
      signInUiShown: (tenantId) => {
        // Show tenant title and additional display info.
      },
      beforeSignInSuccess: (user) => {
        // Do additional processing on user before sign-in is
        // complete.
        return Promise.resolve(user);
      }
    },
    tenants: {
      // Tenant configuration for tenant ID tenantId1.
      tenantId1: {
        // To customize the full tenant selection button label:
        // fullLabel: 'ACME Portal',
        // Display name, button color and icon URL of the
        // tenant selection button.
        displayName: 'ACME',
        buttonColor: '#2F2F2F',
        iconUrl: '<icon-url-of-sign-in-button>',
         // Sign-in providers enabled for tenantId1.
        signInOptions: [
          // Microsoft sign-in.
          {
            provider: 'microsoft.com',
          },
          // Email/password sign-in.
          {
            provider: 'password',
            // Do not require display name on sign up.
            requireDisplayName: false
          },
          // SAML provider.
          {
            provider: 'saml.my-provider1',
            providerName: 'SAML provider',
            // To customize the full label:
            // fullLabel: 'ACME Portal',
            buttonColor: '#4666FF',
            iconUrl: 'https://www.example.com/photos/my_idp/saml.png'
          },
        ],
        signInFlow: 'redirect', // Or popup
      },
      // Tenant configuration for tenant ID tenantId2.
      tenantId2: {
        // To customize the full tenant selection button label:
        // fullLabel: 'OCP Portal',
        displayName: 'OCP',
        buttonColor: '#2F2F2F',
        iconUrl: '<icon-url-of-sign-in-button>',
        // Tenant2 supports SAML, OIDC sign-in.
        signInOptions: [
          // SAML provider. (multiple SAML providers can be passed)
          {
            provider: 'saml.my-provider2',
            providerName: 'SAML provider',
            buttonColor: '#4666FF',
            iconUrl: 'https://www.example.com/photos/my_idp/saml.png'
          },
          // OIDC provider. (multiple OIDC providers can be passed)
          {
            provider: 'oidc.my-provider1',
            providerName: 'OIDC provider',
            // To customize the full label:
            // fullLabel: 'Contractor Login',
            buttonColor: '#4666FF',
            iconUrl: 'https://www.example.com/photos/my_idp/oidc.png'
          },
        ],
      },
    },
  },
};

// Create a FirebaseUiHandler instance.
const handler = new firebaseui.auth.FirebaseUiHandler(
    '#firebaseui-auth-container', configs);
// Initialize a ciap.Authentication instance using the FirebaseUiHandler
// instance.
const ciapInstance = new ciap.Authentication(handler);

// Start the authentication flow.
ciapInstance.start();
```

### Getting the authentication domain
Set the `authdomain` field to the domain provisioned to facilitate federated
sign-in. You can retrieve this field from the
[Identity Platform page](https://console.cloud.google.com/customer-identity)
in the Cloud Console.

### Configuring tenants and providers
A configuration requires a list of tenants and providers that users can
authenticate with. Each tenant has a list of providers; these are specified in
the `signInOptions` field. See
[Configuring sign-in providers in the FirebaseUI](https://github.com/firebase/firebaseui-web#configuring-sign-in-providers)
to learn how to configure providers.

### Choosing a tenant selection mode
Users can select a tenant in two ways: `optionsFirst` mode, or
`identifierFirst` mode.

In options mode, the user begins by selecting a tenant from a list.
In identifier mode, the user enters their email first. The system then
automatically selects the first tenant with an identity provider matching the
email's domain.

To use options mode, set `displayMode` to `optionFirst`. You'll then need to
provide configuration information for each tenant's button, including
`displayName`, `buttonColor`, and `iconUrl`.

The following is an example of a tenant configured to use options mode:

```javascript
tenantId1: {
  // To customize the full tenant selection button label:
  // fullLabel: 'ACME Portal',
  displayName: 'ACME',
  buttonColor: '#2F2F2F',
  iconUrl: '<icon-url-of-sign-in-button>',
  // ...
```

To use identifier mode, each sign-in option must specify an `hd` field
indicating what domain it supports. This can be either a regex
(such as<EMAIL_ADDRESS>or the domain string (e.g., `example.com`).

The code below shows a tenant configured to use identifier mode:

```javascript
tenantId1: {
  signInOptions: [
    // Email/password sign-in.
    {
      hd: 'acme.com', // using regex<EMAIL_ADDRESS>      // ...
    },
```

### Setting up callbacks
The configuration object contains a set of optional callbacks that are invoked
at various points during the authentication flow. This allows you to
additionally customize the UI. The following hooks are available:

|Callback          | Description                                          |
|------------------|------------------------------------------------------|
|selectTenantUiShown()|Triggered when the UI to select a tenant is shown. Use this if you want to modify the UI with a customized title or theme.|
|selectTenantUiHidden()|Triggered when the UI to select a tenant is hidden, which is always before `signInUiShown` is triggered (if applicable). Use this if you want to hide the UI displayed in `selectTenantUiShown`.|
|signInUiShown(tenantId)|Triggered when a tenant is selected and the UI for the user to enter their credentials is shown. Use this if you want to modify the UI with a customized title or theme.|
|beforeSignInSuccess(user)|Triggered before sign-in completes. Use this to modify a signed in user before redirecting back to the IAP resource.|

The following example code shows how you might implement these callbacks:

```javascript
callbacks: {
  selectTenantUiShown: () => {
    // Show info of the IAP resource.
    showUiTitle(
        'Select your employer to access your Health Benefits');
  },
  selectTenantUiHidden: () => {
    // Hide the previous displayed title.
    hideUiTitle();
  },
  signInUiShown: (tenantId) => {
    // Show tenant title and additional display info.
    const tenantName = getTenantNameFromId(tenantId);
    showUiTitle(`Sign in to access your ${tenantName} Health Benefits`);
  },
  beforeSignInSuccess: (user) => {
    // Do additional processing on user before sign-in is
    // complete.
    // For example update the user profile.
    return user.updateProfile({
      photoURL: 'https://example.com/profile/1234/photo.png',
    }).then(function() {
      // To reflect updated photoURL in the ID token, force token
      // refresh.
      return user.getIdToken(true);
    }).then(function() {
      return user;
    });
  }
}
```

### Configuring a single federated provider
If you only have one tenant/top-level project configured for the IAP resouce and
only one provider enabled for the tenant/project, FirebaseUI will act as a proxy
between the IAP resource and the federated IdP without showing any UI before
redirecting to the IdP sign-in page:

```javascript
// The project configurations for a single Facebook identity provider.
const configs = {
  // Configuration for project identified by API key API_KEY1.
  API_KEY1: {
    authDomain: 'project-id1.firebaseapp.com',
    tenants: {
      // The '*' key is used as a fallback when the tenant ID is not found. So
      // you can use it for single tenant/top-level project flow to replace the
      // hardcoded tenant ID or '_'.
      '*': {
        displayName: 'My Organization',
        signInOptions: [
          // Replace Facebook with another provider ID or provider configuration
          // object if you want to use a different IdP.
          firebase.auth.FacebookAuthProvider.PROVIDER_ID,
        ],
        immediateFederatedRedirect: true,
      },
    },
  },
};
```

### Configuring providers for multiple projects
In most cases, you only need to specify a single API key. However, if you want
to use a single authentication URL across multiple projects, you can include
multiple API keys in a single configuration object.

```javascript
const configs = {
  API_KEY1: {
    // Config goes here
  },
  API_KEY2: {
    // Config goes here
  },
}
```

### API reference

```typescript
// The type of the configuration object for FirebaseUiHandler. The key of the
// object is the API key of the project.
type CIAPHandlerConfig = {[key: string]: GCIPProjectConfig};

// Interface that represents the project-level configuration.
interface GCIPProjectConfig {
  // The Auth domain of the project. Retrieve it from
  // https://console.cloud.google.com/customer-identity
  authDomain: string;
  // The display mode of for tenant selection: `optionFirst` or
  // `identifierFirst`. Default: `optionFirst`
  displayMode?: string;
  // The URL of the Terms of Service page or a callback function to be invoked
  // when Terms of Service link is clicked in tenant selection page for
  // optionFirst mode or enter email for tenant matching page for
  // identifierFirst mode.
  tosUrl?: (() => void) | string;
  // The URL of the Privacy Policy page or a callback function to be invoked
  // when Privacy Policy link is clicked in tenant selection page for
  // optionFirst mode or enter email for tenant matching page for
  // identifierFirst mode.
  privacyPolicyUrl?: (() => void) | string;
  // The object of developers callbacks after specific events.
  callbacks?: Callbacks;
  // The tenant-level configurations object. The key of the object is the
  // tenant ID. If using non-tenant flow, use `_` for the key.
  tenants: {[key: string]: TenantConfig};
}

// Interface that represents the available developer callbacks.
interface Callbacks {
  // The callback to trigger when the tenant selection page for optionFirst
  // mode or enter email for tenant matching page for identifierFirst mode
  // is shown.
  selectTenantUiShown?(): void;
  // The callback to trigger when the tenant selection page for optionFirst
  // mode or enter email for tenant matching page for identifierFirst mode
  // is hidden.
  selectTenantUiHidden?(): void;
  // The callback to trigger when the sign-in page is shown. The tenant ID is
  // passed to the callback.
  signInUiShown?(string): void;
  // The callback to triggered before sign-in completes. The signed in user is
  // passed to the callback.
  beforeSignInSuccess?(currentUser: firebase.User): Promise<firebase.User>;
}

// Interface that represents the tenant-level configurations.
interface TenantConfig {
  // The full label for the tenant in the tenant selection buttion. Only needed
  // if you are using the option first mode.
  // When not provided, the "Sign in to $displayName" label is used.
  fullLabel?: string;
  // The display name for tenant in the tenant selection button. Only needed if
  // you are using the option first mode.
  displayName?: string;
  // The color of the tenant selection button. Only needed if you are
  // using the option first mode.
  buttonColor?: string;
  // The URL of the icon for tenant selection button. Only needed
  // if you are using the option first mode.
  iconUrl?: string;
  // A boolean which determines whether to immediately redirect to the
  // provider's site or instead show the default 'Sign in with Provider' button
  // when there is only a single federated provider in signInOptions. In order
  // for this option to take effect, the signInOptions must only hold a single
  // federated provider (like 'google.com') and signInFlow must be set to
  // `redirect`.
  immediateFederatedRedirect?: boolean;
  // The sign-in flow to use for IDP providers: `redirect` or `popup`.
  // Default: `redirect`
  signInFlow?: string;
  // The list of providers enabled for signing into your app. The order you
  // specify them will be the order they are displayed on the sign-in provider
  // selection screen.
  signInOptions: Array<string|SignInOption>;
  // The URL of the Terms of Service page or a callback function to be invoked
  // when Terms of Service link is clicked after the tenant is determind.
  tosUrl?: (() => void) | string;
  // The URL of the Terms of Service page or a callback function to be invoked
  // when Terms of Service link is clicked after the tenant is determind.
  privacyPolicyUrl?: (() => void) | string;
}

// Interface the represent the sign-in provider configuration. Additional
// configurations might be available according to different providers.
interface SignInOption {
  // The provider ID.
  provider: string;
  // The domain string or a regex to match email address. Only needed if you
  // are using the identifier first mode.
  hd?: string;
  // The provider name displayed to end users (sign in button/linking prompt).
  providerName?: string;
  // The color of sign in button.
  buttonColor?: string;
  // The URL of the Identity Provider's icon. This will be displayed on the
  // provider's sign-in button, etc.
  iconUrl?: string;
}

// The FirebaseUI handler to handle the UI flows for tenant selection,
// user authentication, token refreshes and sign-out.
class FirebaseUiHandler {
  constructor(
      element: Element|string,
      configs: {[key: string]: firebaseui.auth.CIAPHandlerConfig});
}
```

## Configuring Authentication URL
You can host your authentication UI using Firebase Hosting or other web hosting
services. Once it's done, register the URL of the authentication UI in the
side panel of [IAP page](https://console.cloud.google.com/security/iap)
in the Cloud Console.
You need to select whether to use `project providers` or `tenants`, and check
the boxes of the providers or tenants to enable.

repository: firebase/firebaseui-web

repo_name: firebase/firebaseui-web


text:
# wbxml-python
Generic Python WBXML decoder based on PyWBXMLDecoder

This is a generic WBXML decoder for Python, based on David Shaw's ActiveSync WBXML decoder
at https://github.com/davidpshaw/PyWBXMLDecoder . The intent of this package is to provide
a feature-complete and extensible WBXML decoder for all valid WBXML codespaces.

license: MIT

repository: dalbergia/wbxml-python

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: dalbergia/wbxml-python


text:
### How these files work

In these files, the NURBS surface made up by 11x11 bicubic NURBS patches are described.

* they all use the _knot vector_ `[0,0,0,0,0.25,0.25,0.25,0.5,0.5,0.75,0.75,0.75,1,1,1,1]`
* in the "`Points`"-file, all the NURBS- control points are described with one point per line, formatted as `[x-coorinate],[y-coordinate],[z-coordinate]`
* in the "`Indices`"-file, the 11x11 points of a NURBS patch are referred to by their line numbers in the "`Points`"-file. Here, each patch has one row, in which the point indices is seperated by commas. The ordering is a simple listing of the rows/columns after each other (interchangable, since the NURBS surfaces are symmetric under exchange of the indices):

`[(1,1)-index], [(1,2)-index], [(1,3)-index], ... , [(1,11)-index], [(2,1)-index], [(2,2)-index], ... , [(2,11)-index], [(3,1)-index], ...`

CAUTION: All indices are MATLAB-style, that is, the first line is referred to as line 1.

repository: mlaradji/CADO

gha_license_id: NOASSERTION

repo_name: mlaradji/CADO


text:
---
layout: single
title:  "Life of a Deployment"
sidebar:
  nav: reference
---

<div class="mermaid">
sequenceDiagram

Title: Life of a Deployment

participant Deck
participant Gate
participant Orca
participant Clouddriver
participant Redis
participant Cloud

Deck->>+Gate: Initiate Deploy orchestration
Gate->>+Orca: Initiate Deploy orchestration
Orca->>Redis: Persist new execution
Orca-->>-Gate: Reply with orchestration id
Gate-->>-Deck: Reply with orchestration id

Note right of Orca: In worker thread
Orca->>+Clouddriver: Initiate Deploy operation
Clouddriver->>Redis: Persist new task
Clouddriver-->>-Orca: Reply with task id

Clouddriver-xCloud: Mutating calls
activate Clouddriver
Clouddriver->>Redis: Mark task completed
deactivate Clouddriver

Loop In worker thread
  Orca->>Clouddriver: Poll until task completion
  Clouddriver->>Redis: Query task status
  Orca->>Redis: Update execution state
end

Loop In worker thread
  Orca->>Clouddriver: Poll until instances are up
  Clouddriver->>Redis: Query server group/instance state from cache
  Orca->>Redis: Mark execution completed
end

Loop In background thread
  Deck->>Gate: Poll until orchestration completion
  Gate->>Orca: Query orchestration status
  Orca->>Redis: Query execution status
end

</div>

{% include mermaid %}

gha_license_id: MIT


text:
# coffeebucks

Welcome to the repo.

This project demonstrates how a general retailer  can utilize blockchain to have cryptocurrency be used to redeem gifts.

## Setup

### Prerequisites

docker version ^17.12.0 and docker-compose version ^1.18.0

### How to Run

```
$ git clone https://github.com/schmidtp0740/coffeebucks.git
$ cd ./coffeebucks
$ docker-compose up
```

## Use Cases

- customer goes to front end website
- customer orders a drink
- payment received and customer is rewarded with coffeebucks tokens
- customer can redeem coffeebucks tokens to order mode drinks


text:
---
layout: event
sidebar: event
title: "50-Year Ache: The role of the faith community in advancing social justice"
starts_at: "2017-11-16T18:00"
ends_at: "2017-11-16T20:00"
location: "Messmer Saint Rose (514 N 31st St.)"
external_link: "https://www.eventbrite.com/e/50-year-ache-the-role-of-the-faith-community-in-advancing-social-justice-tickets-39402321404"
organization: "Milwaukee Journal Sentinel"
---

A knot of problems has persisted in the Milwaukee community for generations. What can be done about it?

From housing to education to jobs and more, the Journal Sentinel is examining complex issues confronting our community to shed light on potential solutions – so that we aren’t still struggling to answer the same questions 50 years from now.

Religious leaders were at the forefront of the civil rights movement in Milwaukee and across the nation. What is the role of the faith community today in advancing social justice?

Doors open at 6 p.m. Panel Discussion, 6:30 p.m. to 8 p.m.
Event Location: Messmer-Saint Rose
514 N. 31st St. Milwaukee, WI 53208

*Parking lot entrance is on 30th Street between Clybourn and Michigan.

gha_language: HTML


text:
---
title: Overview
path_override: "/"
position: 1
layout: documentation
meta:
  title: Overview | OrderLine | HubRise
  description: OrderLine overview, reasons for connecting it to HubRise and summary of integrated features. Synchronise data between your EPOS and your apps.
gallery:
  - __gallery-001.png
  - __gallery-002.png
app_info:
  category: Order Management
  availability: Worldwide
  price_range: Included in your HubRise subscription
  website: https://www.hubrise.com
  contact<EMAIL_ADDRESS>---

OrderLine is a tool provided by HubRise that allows you to seamlessly manage and print orders received from various systems integrated with your HubRise account. OrderLine can be used free of charge on any device, including tablets and smartphones.

Orders might be sourced from a variety of solutions, such as:

- Online ordering solutions for online stores and restaurants.
- Food Ordering and Delivery Platforms.
- On-site self-ordering kiosks.
- Table ordering apps.

It assists single stores, restaurants, and franchises to manage orders received when the EPOS system is not integrated. OrderLine supports delivery, collection, and eat in options. It connects to single HubRise locations.

OrderLine features include:

- Real-time order receipt, with customisable sound notifications.
- Printing of order receipts.
- Update of order status and delivery time.
- Order history.

repository: HubRise/website

gha_language: TypeScript

repo_name: HubRise/website


text:
This plugin allows to mark media manager files with a label, and using a twig filter, retrieve those media manager files url

# Feature

- Add a label to media file manager files and refer to them in template by a twig filter

# Usage

- Select Enhanced Media plugin from the top bar
- Write a label and then select a file
- Open the CMS section and choose a file or partials
- Use the previously defined label with the twig filter `enhanced_media`

````
<img src="{{ 'hero-image'|enhanced_media }}">
````

repository: Nexxa/octobercms-enhanced-media

repo_name: Nexxa/octobercms-enhanced-media


text:
# Routing-Protocols
## Requirements

   Network Simulator 2

Discription

 Tutorials files are for learning purpose.

 wireless2 and wireless3 provides environment.

 Python files are for making graph out of trace files.


text:
---
layout: post
title: "Spectral Analysis of Kernel and Neural Embeddings: Optimization and Generalization"
date: 2019-05-13 15:38:38
categories: arXiv_AI
tags: arXiv_AI Embedding Optimization Quantitative
author: Emilio Jorge, Morteza Haghir Chehreghani, Devdatt Dubhashi
mathjax: true
---

* content
{:toc}

##### Abstract
We extend the recent results of (Arora et al., 2019) by a spectral analysis of representations corresponding to kernel and neural embeddings. They showed that in a simple single layer network, the alignment of the labels to the eigenvectors of the corresponding Gram matrix determines both the convergence of the optimization during training as well as the generalization properties. We show quantitatively that kernel and neural representations improve both optimization and generalization. We give results for the Gaussian kernel and approximations by random Fourier features as well as for embeddings produced by two layer networks trained on different tasks.

##### Abstract (translated by Google)

##### URL
[http://arxiv.org/abs/1905.05095](http://arxiv.org/abs/1905.05095)

##### PDF
[http://arxiv.org/pdf/1905.05095](http://arxiv.org/pdf/1905.05095)


text:
# Basics

Endpoints in Pode are used to bind your server to specific IPs, Hostnames and ports, over specific protocols (such as HTTP or HTTPS). Endpoints can have unique names, so you can bind Routes to certain endpoints only.

## Usage

To add new endpoints to your server, you can use [`Add-PodeEndpoint`](../../../Functions/Core/Add-PodeEndpoint). A quick and simple example is the following, which will bind your server to `http://localhost:8080`:

```powershell
Start-PodeServer {
    Add-PodeEndpoint -Address localhost -Port 8080 -Protocol Http
}
```

The `-Address` can be local or private IP address. The `-Port` is any valid port number, and the `-Protocol` defines which protocol the endpoint will use: HTTP, HTTPS, SMTP, TCP, WS and WSS.

You can also supply an optional unique `-Name` to your endpoint. This name will allow you to bind routes to certain endpoints; so if you have endpoint A and B, and you bind some route to endpoint A, then it won't be accessible over endpoint B.

## Hostnames

You can specify a `-Hostname` for an endpoint, in doing so you can only access routes via the specified hostname. Using a hostname will allow you to have multiple endpoints all using the same IP/Port, but with different hostnames.

The following will create an endpoint with hostname `example.pode.com`, bound to `<IP_ADDRESS>:8080`:

```powershell
Add-PodeEndpoint -Hostname example.pode.com -Port 8080 -Protocol Http
```

To bind a hostname to a specific IP you can use `-Address`:

```powershell
Add-PodeEndpoint -Address <IP_ADDRESS> -Hostname example.pode.com -Port 8080 -Protocol Http
```

or, lookup the hostnames IP from host file or DNS:

```powershell
Add-PodeEndpoint -Hostname example.pode.com -Port 8080 -Protocol Http -LookupHostname
```

Finally, you can bind multiple hostnames to one IP/Port:

```powershell
Add-PodeEndpoint -Address <IP_ADDRESS> -Hostname one.pode.com -Port 8080 -Protocol Http
Add-PodeEndpoint -Address <IP_ADDRESS> -Hostname two.pode.com -Port 8080 -Protocol Http
```

## Certificates

If you add an HTTPS or WSS endpoint, then you'll be required to also supply certificate details. To configure a certificate you can use one of the following parameters:

| Name | Description |
| ---- | ----------- |
| Certificate | The path to a `.pfx` or `.cer` certificate |
| CertificatePassword | The password for the above `.pfx` certificate |
| CertificateThumbprint | The thumbprint of a certificate to find (Windows only) |
| CertificateName | The subject name of a certificate to find (Windows only) |
| CertificateStoreName | The name of the certificate store (Default: My) (Windows only) |
| CertificateStoreLocation | The location of the certificate store (Default: CurrentUser) (Windows only) |
| X509Certificate | A raw X509Certificate object |
| SelfSigned | If supplied, Pode will automatically generate a self-signed certificate as an X509Certificate object |

The below example will create an endpoint using a `.pfx` certificate:

```powershell
Add-PodeEndpoint -Address * -Port 8443 -Protocol Https -Certificate './certs/example.pfx' -CertificatePassword 'hunter2'
```

Whereas the following will instead create an X509Certificate, and pass that to the endpoint instead:

```powershell
$cert = [System.Security.Cryptography.X509Certificates.X509Certificate2]::new('./certs/example.cer')
Add-PodeEndpoint -Address * -Port 8443 -Protocol Https -X509Certificate $cert
```

The below example will create a local self-signed HTTPS endpoint:

```powershell
Add-PodeEndpoint -Address * -Port 8443 -Protocol Https -SelfSigned
```

## Endpoint Names

You can give endpoints unique names by supplying the `-EndpointName` parameter. This name can then be passed to [`Add-PodeRoute`](../../../Functions/Routes/Add-PodeRoute) or [`Add-PodeStaticRoute`](../../../Functions/Routes/Add-PodeStaticRoute) to bind these routes to that endpoint only.

For example:

```powershell
Add-PodeEndpoint -Address localhost -Port 8080 -Protocol Http -EndpointName Example

Add-PodeRoute -Method Get -Path '/about' -EndpointName Example -ScriptBlock {
    # ...
}
```

## Getting Endpoints

The [`Get-PodeEndpoint`](../../../Functions/Core/Get-PodeEndpoint) helper function will allow you to retrieve a list of endpoints configured within Pode. You can use it to retrieve all of the endpoints, or supply filters to retrieve specific endpoints.

To retrieve all of the endpoints, you can call the function will no parameters. To filter, here are some examples:

```powershell
# all endpoints using port 80
Get-PodeEndpoint -Port 80

# all endpoints using HTTP
Get-PodeEndpoint -Protocol Http

# retrieve specific named endpoints
Get-PodeEndpoint -Name Admin, User
```

## Endpoint Object

!!! warning
    Be careful if you choose to edit these objects, as they will affect the server.

The following is the structure of the Endpoint object internally, as well as the object that is returned from [`Get-PodeEndpoint`](../../../Functions/Core/Get-PodeEndpoint):

| Name | Type | Description |
| ---- | ---- | ----------- |
| Name | string | The name of the Endpoint, if a name was supplied |
| Description | string | A description of the Endpoint, usually used for OpenAPI |
| Address | IPAddress | The IP address that will be used for the Endpoint |
| RawAddress | string | The address/host and port of the Endpoint |
| Port | int | The port the Endpoint will use |
| IsIPAddress | bool | Whether or not the listener will bind using Hostname or IP address |
| Hostname | string | The hostname of the Endpoint |
| FriendlyName | string | A user friendly hostname to use when generating internal URLs |
| Url | string | The full base URL of the Endpoint |
| Ssl | bool | Whether or not this Endpoint support support SSL |
| Protocol | string | The protocol of the Endpoint. Such as: HTTP, HTTPS, WS, etc. |
| Type | string | The type of the Endpoint. Such as: HTTP, WS, SMTP, TCP |
| Certificate | hashtable | Details about the certificate that will be used for SSL Endpoints |

repository: ChendrayanV/Pode

repo_name: ChendrayanV/Pode


text:
# Cenangium subnitidum Cooke & W. Phillips, 1875 SPECIES

#### Status
SYNONYM

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

#### Published in
Grevillea 3(no. 28): 186 (1875)

#### Original name
Cenangium subnitidum Cooke & W. Phillips, 1875

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Ascomycota/Leotiomycetes/Helotiales/Dermateaceae/Dermea/Dermea ariae/ Syn. Cenangium subnitidum/README.md

repo_name: mdoering/backbone


text:
### [CVE-2022-1691](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2022-1691)
![](https://img.shields.io/static/v1?label=Product&message=Realty%20Workstation&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=1.0.15%3C%201.0.15%20&color=brighgreen)
![](https://img.shields.io/static/v1?label=Vulnerability&message=CWE-89%20SQL%20Injection&color=brighgreen)

### Description

The Realty Workstation WordPress plugin before 1.0.15 does not sanitise and escape the trans_edit parameter before using it in a SQL statement when an agent edit a transaction, leading to an SQL injection

### POC

#### Reference
- https://bulletin.iese.de/post/realty-workstation_1-0-6

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

repository: trickest/cve

branch_name: refs/heads/main

repo_name: trickest/cve


text:
# Finbuckle.MultiTenant.Contrib
Contribution functionality for [Finbuckle.MultiTenant](https://www.finbuckle.com/MultiTenant).

This is an experimental project intended to provide additional features to a multitenant environment.

View the readme in each project for more details.

## TODO

- [ ] Tests
  - [x] ClaimsStrategy tests
  - [x] FormStrategy tests
  - [x] IdentityServer tests
  - [ ] Identity tests
  - [ ] EF dbcontext and store tests
- [ ] Documentation

gha_language: C#


text:
---
title: "Running Native Executables"
description: ""
lead: "Viash lets you turn your component into a native executable."
date: 2021-06-07T14:00:00+00:00
lastmod: "2021-07-09T14:12:12+00:00"
draft: false
images: []
menu:
  docs:
    parent: "running"
weight: 610
toc: true
---

Native components are a good way to get started with Viash and are ideal
to test out your components before using the more sophisticated
platforms like [Docker](/docs/reference_config/platform-docker/) and
[Nextflow](/docs/reference_config/platform-nextflow/).

```

### Building and running a native executable

To build an executable, use the [viash build
command](/docs/reference_commands/build/):

``` bash
viash build config.vsh.yaml -p native
```

You can then simply run the generated executable:

``` bash
output/my_executable --input "Hello!"
```

## Migrating from native to Docker

Once you’re content with your native executable, you might want to take
it a step further and use it with a Docker backend instead. This has a
few strong advantages over running native components:

-   Executables with a Docker backend are portable.
-   Dependencies are automatically resolved by Viash if you provide some
    information in the config file.
-   You can use specific versions of software packages without having to
    worry about conflicts with a target system’s setup.

Let’s say you have a bash script that uses [curl](https://curl.se/) to
download some data, process it using and then post it to a web server.
When you create a native component for this script, everything will work
fine as long as you have curl installed locally on your machine.
In order to get everything working with a Docker backend, you need to
follow a few simple steps:

If you’re only using the native platform, the platforms section of your
your [config file](/docs/reference_config/config/) will probably look
like this:

``` yaml
platforms:
  - type: native
```

Start off by adding the **docker** platform and a suitable image to the
platforms dictionary. In this case, since you’re using a bash script,
you might want to use the [official bash
image](https://hub.docker.com/_/bash). Replace your existing platforms
section with the following:

``` yaml
platforms:
  - type: native
  - type: docker
    image: bash:latest
```

At this point you can [build and execute the component with a Docker
backend](/docs/running/executables-docker/) already! Viash will do all
the rest. However, if you have *any* dependencies outside of bash, your
script will fail to execute correctly inside of the container.
To remedy this, [Viash allows you to provide the dependencies inside of
the config file](/docs/reference_config/platform-docker/#setup-list) and
they will automatically be resolved at runtime. To add curl as a
dependency, expand your platforms definition like so:

``` yaml
platforms:
  - type: native
  - type: docker
    image: bash:latest
    setup:
      - type: apk
        packages: [ curl ]
```

In this case, curl is available via the **Alpine Package Keeper** (APK
for short). There are many [more ways of adding
dependencies](/docs/reference_config/platform-docker/#setup-list) for
every language Viash supports and more are being added periodically.
Now build your component using this command:

``` bash
viash build config.vsh.yaml -p docker
```

Finally, run the built executable with:

``` bash
output/name_of_your_component
```

That’s it! In just a few steps you’ve made your script ready to be used
on any system that has Docker installed. That includes linux, macOS and
Windows via WSL2.


text:
# cross-country-cabin-craft

Let's create tile-based based worlds in the browser and native devices using react-native-web.

How does this library work and how can I do something similar?

I'm using the react-scripts to create a react app to develop and play with the components in the browser.

```
yarn
yarn start
```

Once I'm happy with them, I run `yarn build` which compiles the code to the `dist` folder. You'll noticed in the `package.json` that the `main` points to `dist/library.js` which is the compiled component library that we eventually import into our projects.

```
npm build
npm publish
```

Within this project, there is also the examples folder. By unlike other npm packages, I'm not really using it that often and I would almost recommend to ignore it.

Instead, after I pubish the project, I like to fire up a [test snack](https://snack.expo.io/@headwinds/two-miles-squared) and update the `cross-country-cabin-craft` dependency to the most recent. Then I can test the library in the browser or directly on my phone.

## Examples folder

You can use the example to verify that the publish to npm was successful but I as mentioned it might as well skip straight to a [snack](https://snack.expo.io/@headwinds/two-miles-squared).

## Help & Thanks

* [react-native-web storybook](https://necolas.github.io/react-native-web/docs/?path=/docs/overview-getting-started--page)
* [how-to-create-a-barebones-production-ready-npm-package-with-babel-7](https://www.cybergrx.com/resources/research-and-insights/blog/how-to-create-a-barebones-production-ready-npm-package-with-babel-7)

## License

MIT © [headwinds](https://github.com/headwinds)

repository: headwinds/cross-country-cabin-craft

repo_name: headwinds/cross-country-cabin-craft


text:
# Example of Resize Observer API with React

- [Demo](https://example-react-resize-observer.sethcorker.com/)
- My [article describing the Resize Observer API in a bit more detail](https://blog.sethcorker.com/resize-observer-api/)

## What is this?

An example of the Resize Observer API being used in React with a custom hook.

## How can I run it?

Once you've cloned the repo, make sure you have node and npm installed. Then just run the usual:
`npm start`

Runs the app in the development mode.

Open [http://localhost:3000](http://localhost:3000) to view it in the browser.

The page will reload if you make edits.

You will also see any lint errors in the console.


text:
---
subject: Meeting: Future of Development (Tomorrow)
to: All Volunteers
preview-text: interested in contributing to our kit and software? We're holding a meeting tomorrow to discuss this.
---

Hi

Now that the competition is over, we have some time to look into future development of kit and competition software.

There will be a meeting held, with SourceBots, as there is a large overlap between our kits.

There are two main deadlines that we will face:
- August 2019: Smallpeice Summer School (SourceBots)
- October / November 2019: Student Robotics Kickstart

An agenda for the meeting has been written and has been [published online][agenda]. Please feel free to add any relevant points that you would like to discuss.

The meeting will be held on **Monday 29th April, 7 - 8pm**.

To join the video meeting, click [this link][gmeet]

There will also be a group of people joining together at Southampton University, in room 53/4025.

We realise that this is quite short notice before the meeting. Sorry, we will try to notify via all channels earlier in the future. If you are unable to make it, we will be publishing minutes for the meeting afterwards in [`#kit-dev`](https://studentrobotics.slack.com/messages/kit-dev) in [Student Robotics Slack][slack]. (Use the [sign-up form][slack-signup] to join the slack if you haven't already)

[agenda]: https://hackmd.io/1zHBGaozQxyxJBvvoaeMVw
[gmeet]: https://meet.google.com/gqd-dpsg-eaa
[slack]: https://studentrobotics.slack.com/
[sro-minutes]: https://github.com/s-r-o/minutes/
[slack-signup]: https://goo.gl/forms/Maq41MHF8CYSRVn83

repository: srobo/volunteer-emails

gha_language: Markdown

repo_name: srobo/volunteer-emails


text:
## Imitation Learning with Dataset Aggregation (DAGGER)

This repository implements a simple algorithm for imitation learning: [DAGGER](https://www.cs.cmu.edu/~sross1/publications/Ross-AIStats11-NoRegret.pdf)

The implementation is tested on the problem of controlling the steering wheel of a vehicle (in simulation) from pixels alone. TORCS is used as the driving simulator, and Keras is used for training a Convolutional Neural Network on the steering angle prediction task.

## Usage
`python dagger.py`

## Requirements
RH: I run on Ubuntu 18.04
1. Python 3.0
2. Keras with Tensorflow backend
3. Numpy
4. [Gym-TORCS](https://github.com/ugo-nama-kun/gym_torcs) [install gym](https://github.com/openai/gym) install torcs: `sudo apt-get install torcs`

5. (added) install [xautomation](http://zoomadmin.com/HowToInstall/UbuntuPackage/xautomation)

## Results

After Iteration 1, crashes after 78 steps

![](http://i.imgur.com/YfqFXQZ.gif)

After Iteration 2, crashes after 151 steps

![](http://i.imgur.com/0bXKyVx.gif)

After Iteration 3, crashes after 395 steps

![](http://i.imgur.com/doz8U0z.gif)

After Iteration 4, the car does not crash anymore: [gif](http://i.imgur.com/pKeVxLY.gif). Image cannot be displayed on the README since it exceeds the content length allowed by Github.

Note: The images fed to the ConvNet are 64x64, the images shown above have been resized to 256x256 for viewing purposes.

repository: RuihanGao/imitation-dagger

repo_name: RuihanGao/imitation-dagger


text:
---
layout: publication
# The quotes make the : possible, otherwise you can do it without quotes
title: "Proving Termination by Divergence"
# YYYY_CONFSHORTNAME_PAPERSHORTNAME
key: 2007_sefm_bchr

# conference | journal | poster | workshop
type: conference
redirect_from: /2007/09/proving-termination-by-divergence

# The shortname is used for auto-generated titles
shortname: SEFM 2007
# add a 2:1 aspect ratio (e.g., width: 400px, height: 200px) to the folder /assets/images/papers/
image: 2007_sefm_bchr.png
# add a 2:1 aspect ratio teaser figure (e.g., width: 1200px, height: 600px) to the folder /assets/images/papers/
image_large: 2007_sefm_bchr_teaser.png

# Authors in the "database" can be used with just the key (lastname). Others can be written properly.
authors:
- Domagoj Babic
- Byron Cook
- Alan J. Hu
- rakamaric

journal-short: SEFM
year: 2007

# bibentry: article | inproceedings | phdthesis | book
bibentry: inproceedings
bib:
  booktitle: Proceedings of the 5th IEEE International Conference on Software
    Engineering and Formal Methods (SEFM)
  series:
  volume:
  publisher: IEEE Computer Society
  editor:
  pages: 93--102
  doi: 10.1109/SEFM.2007.32
  address:
  url:
  number:
  month:
  note:

# Add things like "Best Paper Award at InfoVis 2099, selected out of 4000 submissions"
award: Invited for special section submission to Formal Aspects of Computing (FAC)

# Use if this paper is linked to an internal project. This will link to the project site
# project: upset

# Use this if you have an external project website
external-project:

# The reference to the video entry
video:
# The reference to the preview video entry
#preview-video:

# the preprint
pdf: 2007_sefm_bchr.pdf
# A supplement PDF
supplement:

# Extra supplements, such as talk slides, data sets, etc.
supplements:
- name: Journal Version
  abslink: https://soarlab.org/publications/2012_fac_bchr
  linksym: true
#- name: General UpSet
#  # use link instead of abslink if you want to link to the master directory
#  abslink: http://vials.io/talk/
#  # defaults to a download icon, use this if you want a link-out icon
#  linksym: true

# Link to the repository where the code is hosted
code:

# Link to an official preprint server
preprint_server:
#https://doi.org/10.1101/128579

abstract: "

We describe a simple and efficient algorithm for proving the termination of a
class of loops with nonlinear assignments to variables. The method is based on
divergence testing for each variable in the cone-of-influence of the loop's
termination condition. The analysis allows us to automatically prove the
termination of loops that cannot be handled using previous techniques. The
paper closes with experimental results using short examples drawn from
industrial code.

"

# After the --- you can put information that you want to appear on the website
# using markdown formatting or HTML. A good example are acknowledgements, extra
# references, an erratum, etc.
---
### Acknowledgements

We would like to thank Richard Fateman, Robert Israel, and Daniel Lichtblau for
useful discussions about the complexity of polynomial factorization, divergence
of the update functions, and multivariate limits. We would also like to thank
the anonymous reviewers for several helpful comments and for pointing out the
special case in the computation of safe RGDs.  This work was supported by an
NSERC Discovery Grant, a Microsoft Graduate Fellowship, and a graduate
fellowship from the University of British Columbia.

gha_language: SCSS


text:
# </salt>
## Project description

### Motivation
This is the first project you will work with in this course.
The purpose of this excersize is to take a deep breath and dive in - doing full stack development right from scratch!
However, as this is your first encounter with the Javascript Node.js stack, it will pretty much be a _fill the gaps_ project.

You will be using the latest Node.js stack teqniques to build a full stack application.
But(!) in this first project, we will use a minimal set of frameworks so that you will learn the fundamentals first.
The upside of that is that you will
  - become better programmers
  - not depend on only one set of frameworks
  - it will be easier and more fun to code as the course proceeds

### Domain
This project is entirely created to start off this course and does not reflect any realistic product. The domain is rather scattered.

Anyway, a finished app will have
  - simple login and authentication
  - a quotes generator
  - a list of "players" (think sports team)
  - a way to rate these players by giving them "stars"

## Getting started
### Initialize
Run `npm install` in root folder.

### Eslint
Javascript is a dynamic language.
This will give us a very productive environment with fast feedback cycles.
The downside of that is that we loose the compiler checks that would otherwise catch bugs for us.
To work around that in Javascript, we use linters that check our code - both for style and erroneous code constructs.

Run `npm run lint` to lint the code (there might not be any errors in this branch though!).

### Unit Tests
We practice test driven development (TDD).
This means that we first write a failing test (red light), which acts as a specification for the feature we're about to implement.
_Then_ we write the most basic implementation (nothing more!) that we can think of to make the test pass (green light).

When the code passes our test, we know that we've solved the problem. But we are not done!
Now it's time to refactor the code with the passing test as our guide.
We remove any code duplications, and make the code better and more robust so that we can confidently say we've solved the problem with our best efforts.

We often say that we go through a feedback cycle called `red - green - refactor`:
  - Red: Write a failing test
  - Green: Write the most basic solution to the test you can think of
  - Refactor: Make the code production ready

This way of working serves several purposes
  - When done right, it's a way easier to work this way as we're solving many trivial micro problems instead of a few complex problems
  - We'll build up a test suite along with any new features that acts as a safety net as we develop our application
  - We will enforce loose coupling and good design practices.

Run `npm run test` to run all tests once.

### Start the Server
The development server is started by running `npm run start`. This will also lint the code and restart the server on any file change.

Point your browser to `http://localhost:3000` and go!

### End to End Tests
End to end (e2e) test serves a different purpose than unit tests.
While unit tests focus on details and system design, e2e tests focus on the overall picture.

Typically there is a lot more ceremony around running e2e tests and the feedback loop is slower by magnitudes.
They are also more brittle to change. But that doesn't mean we shouldn't do e2e tests - we're just not doing so many of them or running them at the same frequency.

The e2e test suite is using _Selenium_, which is a browser simulation environment.
Typically, it will load a web page info your browser and programmatically let you verify the content of that page.

Before you run Selenium the first time, you must run the install script like so `npm run selenium-setup`.

After that you start the Selenium server `npm run selenium`.

Next step is to start your web server from another terminal.
Open a new terminal, navigate to this projects root directory and run `npm run start`.

Now you are finally ready to run the test suite!
Open yet another terminal, navigate to this projects root directory and run `npm run e2e`.

## Exercise
Head over to the branch day-1 for further instructions.


text:
# bazel2cmake notes

## Facts and problems

*   There are 3 types of Bazel files: *BUILD* (*BUILD.bazel*) files, *.bzl*
    files, and *WORKSPACE* files.
*   To make sense of a *BUILD* file, you have to at least *find* the *WORKSPACE*
    file; this determines the meaning of "absolute" paths (labels).
*   It's tempting to entirely ignore other (external) workspaces, and indeed
    there are good reasons for doing so.
    *   In translating Bazel to CMake, you probably don't want to automatically
        cross workspace boundaries.
    *   Even if you actually depend on something from another workspace, it's
        quite possible that that workspace has a more natural, "native" (e.g.,
        handwritten) CMake build.
    *   So you'd at least want to *support* mapping external dependencies to a
        CMake dependency of some other name.
*   All that said, it's hard to simply ignore external workspaces. E.g., they
    may provide macros that are used in your own *BUILD* files, in which case
    you at least need to be able to load *.bzl* files from them.
    *   Being able to fetch dependencies poses a significant problem, but
        luckily Bazel provides the `bazel fetch` and `bazel sync` commands.
*   *BUILD* files, *.bzl* files, and *WORKSPACE* files differ in what is
    permitted.
    *   Most glaringly, *BUILD* and *WORKSPACE* files use a restricted subset of
        Starlark (e.g., `**kwargs` is not allowed).

## Decisions

*   Read *WORKSPACE* files, just to glean the workspace name. We could skip this
    if it's too troublesome.
*   Assume that other workspaces are available under *\<outputBase\>/external*
    (see https://docs.bazel.build/versions/master/output_directories.html for
    the definition of *\<outputBase\>*).
    *   `bazel sync` will fetch all dependencies. (There's also `bazel fetch`.)
    *   *bazel-\<project name\>* (where *\<project name\>* is the name of the
        directory containing the *WORKSPACE* file) doesn't contain everything,
        so accessing the *\<outputBase\>* really is necessary.
*   This is enough to load *.bzl* files from other workspaces, as far as I can
    tell. (Presumably, any name mappings are *not* applied in this case, or so I
    hope. Or, rather, name mappings are only applied when a *BUILD* file is
    executed, or perhaps even later. It cannot be done at *.bzl* load time,
    because the interpreter has no way of knowing what strings are labels.)

gha_language: Go


text:
---
---

1 can Salmon, drained , skinned, boned and flaked (small can)
2 eggs, slightly beaten
1/2 cup milk
1/2 teaspoon salt
1/8 teaspoon pepper
1 teaspoon lemon juice
1 teaspoon chopped onion
1 tablespoon chopped green pepper (optional)
2 cups Special-K cereal (or use 1/2 to 1 cup cracker crumbs)

Combine all ingredients and mix well. Spread in greased 9x5 loaf pan. Bake at 350 degrees for
30 minutes.

Top with cheese sauce:
Make 1 cup thick white sauce and add 1/4 cup cheddar cheese. When cheese melts, pour over
salmon loaf and serve.

repository: rdyar/tdfc

branch_name: refs/heads/gh-pages

gha_language: CSS

repo_name: rdyar/tdfc


text:
**NOTICE: This repository has been archived, and will no longer be maintained or accept pull requests.**

## Silent Gateway Documentation ##

**Silent Gateway Documentation** is a set of documentation, helper VIs, and an example to launch NI VeriStand's gateway silently. With the gateway operating silently, NI VeriStand API calls can be made without launching NI VeriStand.

### LabVIEW Version ###

LabVIEW 2011

### Built Availability ###

No builds are available. You can build them yourself with the provided project.

### Quality, Limitations ###

This is an unsupported feature of NI VeriStand and should be used with caution and plenty of testing. It has been available since 2010.

### License ###

*This repository and any materials provided by NI therein are provided AS IS.  NI shall have no liability for any direct, indirect, incidental, punitive, special, or consequential damages for your use of the repository or any materials contained therein.*


text:
# Import Cost coc.nvim Extension ![Build Status](https://github.com/wix/import-cost/workflows/build/badge.svg)

This extension will display inline in the editor the size of the imported package.
The extension utilizes webpack with babili-webpack-plugin in order to detect the imported size.
![Example Image](images/coc-import-cost.gif)

## Requirements

This is an extension for [coc.nvim](https://github.com/neoclide/coc.nvim) and requires that it be installed first.

## Installation

Once you have `coc.nvim` installed, open Vim/Neovim, and execute:

```
:CocInstall coc-import-cost
```

You'll also need to enable the code lens feature in coc (`:CocConfig`):
```
"codeLens.enable": true
```

## Features

Calculates the size of imports and requires.
Currently supports:

* Default importing: `import Func from 'utils';`
* Entire content importing: `import * as Utils from 'utils';`
* Selective importing: `import {Func} from 'utils';`
* Selective importing with alias: `import {orig as alias} from 'utils';`
* Submodule importing: `import Func from 'utils/Func';`
* Require: `const Func = require('utils').Func;`
* Supports both `Javascript` and `Typescript`

## Why & How

We detail the why and how in this blog post:
[https://medium.com/@yairhaimo/keep-your-bundle-size-under-control-with-import-cost-vscode-extension-5d476b3c5a76]()

## Configuration

The following properties are configurable:

```javascript
  // File extensions to be parsed by the Typescript parser
  "importCost.typescriptExtensions": [
    "\\.tsx?$"
  ],

  // File extensions to be parsed by the Javascript parser
  "importCost.javascriptExtensions": [
    "\\.jsx?$"
  ],

  // Which bundle size to display
  "importCost.bundleSizeDecoration": "both",

  // Display the 'calculating' decoration
  "importCost.showCalculatingDecoration": true,

  // Print debug messages in output channel
  "importCost.debug": false
```

## Known Issues

* Importing two libraries with a common dependency will show the size of both libraries isolated from each other, even if the common library needs to be imported only once.

repository: wix/import-cost

gha_language: JavaScript

repo_name: wix/import-cost


text:
cbfg
====

An experiment / prototype in distributed systems modeling,
simulation and (perhaps one day) code-gen.

This was initially discussed over lunch at a Five Guys burger
restaurant, so "c.b.f.g." means couchbase five guys.  Clearly, this is
a backronym waiting for future reassignment.

# grab the code...

    git clone git@github.com:couchbaselabs/cbfg.git

# for cbfg developers...

## grab the dependencies...

    git clone git@github.com:couchbaselabs/ago.git

## setup the dependencies...

    cd cbfg
    mkdir checkouts
    cd checkouts
    ln -s ../../ago .
    cd ..

# build...

You'll need the [lein](http://github.com/technomancy/leiningen)
toolchain, so that you can run...

    lein cljsbuild once cbfg

Or, during development cycle, instead run...

    lein cljsbuild auto cbfg

# run a local webserver...

    $ python -m SimpleHTTPServer
    Serving HTTP on <IP_ADDRESS> port 8000 ...

# browse...

    http://localhost:8000
    http://localhost:8000/world-t1.html
    http://localhost:8000/world-t2.html

# for some codegen...

    lein run src/cbfg/fence.cljs

repository: couchbaselabs/cbfg

repo_name: couchbaselabs/cbfg


text:
![Build Status](https://travis-ci.org/cibernox/ember-native-dom-helpers.svg?branch=master)

# ember-native-dom-helpers

Test helpers for integration tests that mimic the behaviour of the acceptance
test helpers provided by Ember.

Use this addon as a way to start the gradual migration towards the future
["testing unification" RFC][emberjs/rfcs/pull/119], which proposes only native DOM.

See the [Grand Testing Unification RFC][emberjs/rfcs/pull/119]

- [shared-test-helpers]
- [example-migration-of-component-integration-test]

[emberjs/rfcs/pull/119]: https://github.com/emberjs/rfcs/pull/119
[shared-test-helpers]: https://github.com/rwjblue/rfcs/blob/42/text/0000-grand-testing-unification.md#shared-test-helpers
[example-migration-of-component-integration-test]: https://github.com/rwjblue/rfcs/blob/42/text/0000-grand-testing-unification.md#example-migration-of-component-integration-test

**Status**: (Pre) 1.0, although we have a good idea about what the needs are for
test helpers, we are working through a few points on what changes are needed
when using only standard DOM APIs (i.e. without jQuery).

## Usage

### Integration tests

```js
import { click, fillIn, find, findAll, keyEvent, triggerEvent } from 'ember-native-dom-helpers';

moduleForComponent('my-component', 'Integration | Component | my-component', {
  integration: true
});

test('I can interact with my component', async function(assert) {
  this.render(hbs```
    {{my-component}}
  ```);

  await fillIn('.some-input', 'some text');
  await click('.main-button');
  await keyEvent('.other-input', 'keyup', 40); // down arrow
  await triggerEvent('.some-drop-area', 'mouseenter');

  assert.ok(find('.result-of-event-happened'));
  assert.equal(findAll('.result-list-item').length, 3);
})
```

### Acceptance tests

You can use the exact same helpers for your acceptance tests. All interaction helpers like
`click`, `fillIn`, et al., return a promise that fullfils when "the world has settled"
(that is, there are no pending requests or promises, and the runloop has been drained), which
is what the `andThen` acceptance helper used to do. However, this helper can now be replaced
by the `async`/`await` syntax in ES2017, yielding easier-to-read tests:

```js
import { visit, click, find, fillIn } from 'ember-native-dom-helpers';

moduleForAcceptance('Acceptance | Sign up');

test('Usage awaiting the world to settle', async function(assert) {
  await visit('/sign-up');

  await fillIn('.first-name', 'Chuck');
  await fillIn('.last-name', 'Berry');
  await click('.submit-btn');

  assert.ok(find('.welcome-msg'), 'There is a welcome banner');
  assert.equal(find('.welcome-msg-name'), 'Chuck');
});
```

## Advantages compared with `this.$(selector).click()`

The main advantages are:

- Fires native events: In Ember, when adding events with the `onclick={{action "foo"}}` syntax,
  dispatching jQuery events leads to the action being called twice. Additionally, there are subtle
  differences between jQuery and Native events that can bite you. Firing native events fixes that
  problem, but they are very verbose and there are browser incompatibilities. This addon makes
  firing native events a no-brainer.

- Runloop aware: These helpers automatically spawn a runloop, so you don't need to wrap
  every interaction with `Ember.run(() => /* interact with element */ );`.

- `wait` by default: All the helpers return the `wait()` promise, making it possible to
  wait for asynchronous side-effects with `async/await`. (Note that for using async/await
  in browsers without native support you must install [ember-maybe-import-regenerator](https://github.com/machty/ember-maybe-import-regenerator)).

  ```js
  test('some test', async function(assert) {
    this.render(hbs```{{my-component}}```);

    await click('.my-button');

    assert.ok('something happened');
  });
  ```

- More realistic behaviour: When a user clicks on an element, `click` is not the only event fired.
  In a real click, the sequence of events is `mousedown`, `focus`, `mouseup`, `click`. When a user
  fills in an input the sequence of events is `focus`, `<mutate-value>`, `input`, and `change`.
  The helpers provided by this addon fire those events in the right order, simulating more
  closely how a real user would interact with the page.

## Standard DOM elements returned using a `find`/`findAll` helpers

- The `find` helper uses `document.querySelector` and will return a single `HTMLElement` or `null`.
- The `findAll` helper uses `document.querySelectorAll` and returns an `Array` with zero or more elements.
- Both `find` and `findAll` helpers query the DOM within `#ember-testing`.
- To use a different value from your `config/environment.js` settings, add to `tests/test-helper.js`…

```js
import { settings } from 'ember-native-dom-helpers';
import config from '../config/environment';
const { APP: { rootElement } } = config;

settings.rootElement = rootElement || settings.rootElement;
```

### What if I prefer jQuery collections over native DOM?

Fear not. If you prefer to use jQuery, just wrap the result and do your thing:

```js
assert.equal($(find('.my-class')).attr('aria-owns'), '#id123')
```

## Testing an unsettled world

There is one new helper in this addon that enables some testing patterns that weren't
previously easy to perform using traditional methods.

Since the `andThen` helper waits for the app to settle (no pending requests or promises),
and every integration test interaction is wrapped in `Ember.run`, there is no easy way
to test transient state, like loading substates or the state of a component, while some
promise is pending, without an awkward setup of timeouts.

Now, however, thanks to explicit usage of promises and the `waitUntil` helper, you can
perform assertions on unsettled states:

```js
import { visit, click, find, fillIn, waitUntil, currentURL } from 'ember-native-dom-helpers';

moduleForAcceptance('Acceptance | Sign up');

test('Usage awaiting the world to settle', async function(assert) {
  await visit('/login');

  await fillIn('.email', '007@gov.uk');
  await fillIn('.password', 'goldeneye');
  let promise = click('.submit-btn');

  // We wait until the loading substate, that takes 200ms to appear, is displayed
  await waitUntil(() => find('.substate-spinner'));
  assert.equal(find('.loading-substate-header').textContent.trim(), 'Loading mission. Please wait, Mr. Bond');

  await promise; // now we wait until the dashboard is fully loaded
  assert.equal(currentURL(), '/dashboard');
  assert.equal(find('.section-header').textContent, 'Main dashboard');
});
```

## I WANT IT NOW, IS THERE A SHORTCUT?

Yes, there is a codemod that will help you transform your test suite to this new style "automatically".
Check https://github.com/simonihmig/ember-native-dom-helpers-codemod.

The codemod can't make a *perfect* conversion, but it will do most of the work for you.

## Helpers

- `click(selectorOrHTMLElement, eventOptions)`
- `tap(selectorOrHTMLElement, eventOptions)`
- `fillIn(selectorOrHTMLElement, text)`
- `find(selector, contextHTMLElement)` (query for an element in test DOM, `#ember-testing`)
- `findAll(selector, context)` (query for elements in test DOM, `#ember-testing`)
- `findWithAssert(selector, contextHTMLElement)` (same as `find`, but raises an Error if no result)
- `keyEvent(selectorOrHTMLElement, type, keyCode, modifiers)` (type being `keydown`, `keyup` or `keypress`, modifiers being object with `{ ctrlKey: false, altKey: false, shiftKey: false, metaKey: false }`)
- `triggerEvent(selectorOrHTMLElement, type, options)`
- `focus(selectorOrHTMLElement)`
- `blur(selectorOrHTMLElement)`
- `scrollTo(selectorOrHTMLElement, x, y)`
- `selectFiles(selectorOrHTMLElement, files = [])` (selects the file(s)/Blob(s) to the given `input[type=file]`. [Example](https://github.com/cibernox/ember-native-dom-helpers/blob/2f5f4d1df29d0d546505b515ca3e11721a86274b/tests/integration/select-files-test.js#L32-L35)
- `visit(url)` (only available in acceptance. Raises an error in integration.)
- `waitUntil(function, options)` (Polls the page until the given callback returns a truthy value, or timesout after 1s)
- `waitFor(selector, options)` (Convenience for the most common use-case of `waitUntil`. It polls the page until the element with the given selector is on the page, or timesout after 1s. It accepts a `count: 3` option to await a specific number of matches.)
- `currentURL()` Identical to the one provided by Ember.
- `currentPath()` Identical to the one provided by Ember.
- `currentRouteName()` Identical to the one provided by Ember.

## Notes of `tap`

In order for `tap` to work, your browser has to support touch events. Desktop Chrome and Firefox
have touch events disabled unless the device emulation mode is on. To enable touch events in your
CI, you need to configure testem like the `testem.js` file on this repo.


text:
# supdate

Clojure's update with superpowers.

[![Clojars Project](https://img.shields.io/clojars/v/vvvvalvalval/supdate.svg)](https://clojars.org/vvvvalvalval/supdate)

This library provides a `supdate` macro which lets you transform Clojure data structures
declaratively, using a data-driven specification which structure matches the schema of the input.

The benefit is that such specifications eliminate a lot of the boilerplate code involved
 when transforming nested data structures.

In addition, `supdate` is a macro that leverages static information on a best-effort basis
in order to make the performance comparable to hand-written code.
Dynamic pre-compilation (via `compile`) is also available to achieve better performance while remaining fully dynamic.

## Usage

```clojure
(require '[vvvvalvalval.supdate.api :as supd :refer [supdate]])

;; canonical example
(def my-input
  {:a 1
   :b [1 2 3]
   :c {"d" [{:e 1 :f 1} {:e 2 :f 2}]}
   :g 0
   :h 0
   :i 0})

(supdate
  my-input
  {:a inc
   :b [inc]
   :c {"d" [{:e inc}]}
   :g [inc inc inc]
   :my-missing-key inc
   :i false
   })
=> {:a 2,
    :b [2 3 4],
    :c {"d" [{:e 2, :f 1} {:e 3, :f 2}]}
    :g 3,
    :h 0}
```

See also the [tests](https://github.com/vvvvalvalval/supdate/blob/master/test/vvvvalvalval/supdate/test/api.clj)
 for more examples.

### Emulating standard library operations

`supdate` generalizes several functions of Clojure's standard library:

```clojure

;;;; Emulating clojure.core/update
(update {:a 1 :b 1} :a inc)
=> {:a 2 :b 1}
(supdate {:a 1 :b 1} {:a inc})
=> {:a 2 :b 1}

;;;; Emulating clojure.core/update-in
(update-in {:a {"b" [{:c 1}]}}
  [:a "b" 0 :c] inc)
=> {:a {"b" [{:c 2}]}}
(supdate {:a {"b" [{:c 1}]}}
  {:a {"b" {0 {:c inc}}}})
=> {:a {"b" [{:c 2}]}}
;; NOTE: unlike update-in, if a key is missing in the input,
;; the transformation will be skipped instead of creating new maps.

;;;; Emulating clojure.core/map
(map dec (range 10))
=> (-1 0 1 2 3 4 5 6 7 8)
(supdate (range 10) [dec])
=> (-1 0 1 2 3 4 5 6 7 8)
;; Note: unlike map, if the input is a vector, the output will also be a vector.

;;;; Emulating dissoc
(dissoc {:a 1 :b 2 :c 3}
  :a :b :d)
=> {:c 3}
(supdate {:a 1 :b 2 :c 3}
  {:a false :b false})
=> {:c 3}
```

### Pre-compiling transforms

A `compile` function is available to make execution faster:

```clojure

(def transform
  (supd/compile {:a inc
                 :b [inc]
                 :c {"d" [{:e inc}]}
                 :g [inc inc inc]
                 :missing-key inc
                 :i false
                 }))

(transform {:a 1
            :b [1 2 3]
            :c {"d" [{:e 1 :f 1} {:e 2 :f 2}]}
            :g 0
            :h 0
            :i 0})
=> {:a 2,
    :b [2 3 4],
    :c {"d" [{:e 2, :f 1} {:e 3, :f 2}]}
    :g 3,
    :h 0}

```

## Comparison to [Specter](https://github.com/nathanmarz/specter)

This library is in the same space as Specter, but we don't see it as a replacement to Specter.
We believe this library is useful in situations where using Specter is overkill.

More specifically:

* Specter's `transform` is useful for making one sophisticated transformation,
 whereas `supdate` is good at making many basic transformations at once.
* Specter provides a `select` operation, supdate is only about transformation.
* Arguably, supdate is easier to learn.
* Specter is extensible, supdate is not.

## License

Copyright © 2016 Valentin Waeselynck and contributors

Distributed under the MIT License.

repository: vvvvalvalval/supdate

gha_language: Clojure

repo_name: vvvvalvalval/supdate


text:
# Vim

## Ideas for future

## Learn

* Registers
* Learn debugger: https://github.com/mfussenegger/nvim-dap
* Remember mappings:
  * `gv` = reselect last visual.
  * `<C-u>` = undo in insert.
  * `<C-x><C-f>` = auto complete file+path.
  * `cw, caw, ciw` = change word, change around, change inside
  * `o` = move other direction inside visual
* Consider `set shiftround` (round indent space to closets multiple of shiftwidth)
* The full power of pattern matching:
  * Use and reuse the match `&` char
  * Dealing with cases:
    ```
    \U – when used in a replacement pattern, uppercases everything after it
    \L – lowercases everything after it
    \u – uppercases the first character of what follows
    \l – lowercases the first character of what follows
    \e or \E – stops the uppercasing or lowercasing
    ```

repository: alexanderlhc/dotfiles-retired

repo_name: alexanderlhc/dotfiles-retired


text:
# Pagination Navigation

> Quick first, previous, next, last, and page buttons for pagination based navigation, supporting
regular links or router links.

```html
<template>
<div>
  <h6>Default</h6>
  <b-pagination-nav base-url="#" :number-of-pages="10" v-model="currentPage" />

  <h6 class="mt-4">With link generator function</h6>
  <b-pagination-nav :link-gen="linkGen" :number-of-pages="10" v-model="currentPage" />
  <br>

  <div class="mt-4">currentPage: {{currentPage}}</div>
</div>
</template>

<script>
export default {
  data () {
    return {
      currentPage: 1
    }
  },
  methods: {
    linkGen (pageNum) {
      return '#page/' + pageNum + '/foobar'
    }
  }
}
</script>

<!-- pagination-1.vue -->
```

`<b-pagination-nav>` is a custom input component that provides navigational
pagination. The current page should be set via the `value` prop (or `v-model`),
and the total number of pages set with `number-of-pages`. Page numbers are indexed
from 1 through `number-of-pages`.

## Current page

You should **always** set the current page number by setting the prop `value` (or
using `v-model`) to ensure that correct active page number is highlighted.

## Link generation

By default, `<b-pagination-nav>` generates plain link tags, setting the HREF attribute
to `base-url` concatenated with the page number. The `base-url` prop defaults to '/'.

### Router links

To generate page links as [`<router link>`](https://router.vuejs.org/en/api/router-link.html)
components, set the `use-router` prop. The HREF will then become the `to` prop of
the router link.

### Link Generator function

If you need finer grained control over the generated link URLs or `<router-link>` `to` props,
you may set the `link-gen` prop to a function reference that accepts one argument which
is a page number. The `link-gen` function should return either a string (for HREF) or a
router `to` object. If the returned value is an object, then a router-link will always
be generated. If the return value is a string, a link is generated by default unless
the `use-router` prop is set.

```js
// For regular HREF (or string `to` prop if `use-router` is set)
linkGen(pageNum) {
  return '/foo/page/' + pageNum
}

// Returning a router-link `to` object
linkGen(pageNum) {
  return {
    path: '/foo/page/' + pageNum
  }
}
```

### Page number generation

By default, `<b-pagination-nav>` renders page numbers (1-N) in the page link
buttons. You can override this behaviour by supplying a function reference to
the `page-gen` property. The function reference should accept a single argument
which is a page number (1-N). The `page-gen` function should return a string.

Note HTML strings are currently not supported.

**Example: Using an array of links to generate pagination:**

```html
<template>
  <div>
    <b-pagination-nav :link-gen="linkGen"
                      :page-gen="pageGen"
                      :number-of-pages="links.length"
                      v-model="currentPage" />
    <br>
    <p>
      Page #: {{ currentPage }}<br>
      Page Link: {{ pageLink }}
    </p>
  </div>
</template>

<script>
export default {
  computed: {
    pageLink () {
      return this.linkGen(this.currentPage)
    }
  },
  data () {
    return {
      currentPage: 1,
      links: ['#foo', '#bar', '#baz', '#faz']
    }
  },
  methods: {
    linkGen (pageNum) {
      return this.links[pageNum - 1]
    },
    pageGen (pageNum) {
      return this.links[pageNum - 1].slice(1)
    }
  }
}
</script>

<!-- pagination-nav-links.vue -->
```
## Button Size
Optionally change from the default button size by setting the `size`
prop to eiter `'am` for smaller buttons or `'lg'` for larger buttons.

```html
<template>
<div>
  <h6>Small</h6>
  <b-pagination-nav size="sm" base-url="#" :number-of-pages="5" v-model="currentPage" />

  <h6>Default</h6>
  <b-pagination-nav base-url="#" :number-of-pages="5" v-model="currentPage" />

  <h6>Large</h6>
  <b-pagination-nav size="lg" base-url="#" :number-of-pages="5" v-model="currentPage" />
</div>
</template>

<script>
export default {
  data () {
    return {
      currentPage: 1
    }
  }
}
</script>

<!-- pagination-size.vue -->
```

## Customizing

`<b-pagination-nav>` supports several props that allow you to customize the appearance.

| Prop | Description
| ---- | -----------
| `limit` | Limit the maximum number of displayed page buttons (including ellipsis if present, and excluding first/prev/next/last buttons)
| `number-of-pages` | The total number of pages
| `first-text` | The "goto first page" button text (html supported)
| `prev-text` | The "goto previous page" button text (html supported)
| `next-text` | The "goto next page" button text (html supported)
| `last-text` | The "goto last page" button text (html supported)
| `ellipsis-text` | the `...` indicator text (html supported)
| `hide-ellipsis` | never show ellipsis indicators
| `hide-goto-end-buttons` | never display goto first/last buttons

Ellipsis indicator(s) will only be ever shown at the front and/or end of
the page number buttons. For `limit` values less than or equal to `3`, the ellipsis
indicator(s) will never be shown for practical display reasons.

## Alignment

By default the pagination component is left aligned. Change the alignment to
`center` or `right` (`right` is an alias for `end`) by setting the prop
`align` to the appropriate value.

```html
<template>
<div>
  <h6>Left alignment (default)</h6>
  <b-pagination-nav :number-of-pages="10" base-url="#" v-model="currentPage" />
  <br>

  <h6>Center alignment</h6>
  <b-pagination-nav align="center" :number-of-pages="10" base-url="#" v-model="currentPage" />
  <br>

  <h6>Right (end) alignment</h6>
  <b-pagination-nav align="right" :number-of-pages="10" base-url="#" v-model="currentPage" />
  <br>

  <div>currentPage: {{currentPage}}</div>
</div>
</template>

<script>
export default {
  data () {
    return {
      currentPage: 1
    }
  }
}
</script>

<!-- pagination-align.vue -->
```

## Small screen support

On smaller screens (i.e. mobile), some of the `<b-pagination>` buttons will be hidden to
minimize the potential of the pagination interface wrapping onto multiple lines:

- The ellipsis indicators will be hidden on screens `xs` and smaller.
- Page number buttons will be limited to a maximum of 3 visible on `xs` screens and smaller.

This ensures that no more than 3 page number buttons are visible,
along with the goto _first_, _prev_, _next_, and _last_ buttons.

## Accessibility

The `<b-pagination>` component provides many features to support assistive technology users,
such as `aria-` attributes and keyboard navigation.

### ARIA labels:

`<b-pagination>` provides various `*-label-*` props which are used to set the `aria-label`
attributes on the various elements within the component, which will help users of
assistive technology.

| Prop | `aria-label` content default
| ---- | -----------
| `label-first-page` | "Go to first page"
| `label-prev-page` | "Go to previous page"
| `label-next-page` | "Go to next page"
| `label-last-page` | "Go to last page"
| `label-page` | "Go to page", appended with the page number
| `aria-label` | "Pagination", applied to the outer pagination container

### Keyboard navigtion support:

`<b-pagination>` supports keyboard navigation out of the box.
- Tabbing into the pagination component will auto-focus the current page button
- LEFT and RIGHT arrow keys will focus the previous and next buttons in the page
list, respectively, and ENTER or SPACE keys will select (click) the focused page button

## See also

For pagination control of a component (such as `<b-table>`), use the
[`<b-pagination>`](./pagination) component instead.

## Component Reference

repository: Kevintjeb/KaraokeJam

gha_language: Vue

repo_name: Kevintjeb/KaraokeJam


text:
# telegraf-consul Docker image

Docker image that runs [Telegraf][1] with its configuration driven via
[Consul-Template][2].

## NOTE
This image currently uses a patched build of consul-template (included with this
repo) due to https://github.com/hashicorp/consul-template/pull/749. This fix has
been merged but not yet released. The included binary is `0.16.0` plus the fix.

## Environment Variables
Use `TELEGRAF_CONF_KEY` to set the key prefix where the telegraf configuration
will be found in Consul. If not set, `telegraf` will be used.

Also, you must set `CONSUL_HTTP_ADDR` in order for consul-template to render
any templates when the container runs. Any supported consul-template environment
variables can be used, such as:

- CONSUL_HTTP_ADDR
- CONSUL_HTTP_TOKEN
- CONSUL_HTTP_AUTH
- CONSUL_HTTP_SSL
- CONSUL_HTTP_SSL_VERIFY

## Supported Consul keys
- `<conf_key>/global_tags/*` - global tag key/value pairs
- `<conf_key>/agent/*` - any valid agent key/value pairs
- `<conf_key>/inputs/<input_type>/<input_name>/*` - telegraf input(s)*
- `<conf_key>/inputs/<output_type>/<output_name>/*` - telegraf outputs(s)*

The keys/values will be converted to a TOML telegraf config.

### Inputs/Output Configurations
Since telegraf inputs/outputs are actually arrays (can have multiple of each
type) and Consul K/Vs are a map, an (arbitrary) name is required for each
input/output for uniqueness and to "array-ify" them.

### Value Types
Since Consul basically stores everything as strings and values in the telegraf
TOML config may require strings, values, or arrays, Consul KV values are converted
as follows:

- any value matching `True`, `true`, `False`, `false` will be treated as Boolean
- any value that can be converted to float will be treated as numeric
- any value beginning with `[` and ending with `]` will be treated as an array
- any value matching `{}` will be treated as an empty map
- anything else will be string

## Example
The following example Consul keys/values:
```
KEY                                                  VALUE
telegraf/agent/omit_hostname                         true
telegraf/outputs/influxdb/1/urls                     ["http://<IP_ADDRESS>:8086"]
telegraf/inputs/mongodb/cluster1/servers             ["mongo1.example.com:27017"]
telegraf/inputs/mongodb/cluster1/gather_perdb_stats  true
telegraf/inputs/mongodb/cluster2/servers             ["<IP_ADDRESS>:27017"]
telegraf/inputs/mem/foo                              {}
```

Will generate the following effective telegraf.conf:
```
[agent]
omit_hostname = true

[[outputs.influxdb]]
urls = ["http://<IP_ADDRESS>:8086"]

[[inputs.mongodb]]
servers = ["mongo1.example.com:27017"]
gather_perdb_stats = true

[[inputs.mongodb]]
servers = ["<IP_ADDRESS>:27017"]

[[inputs.mem]] # empty - no config necessary
```

[1]: https://github.com/influxdata/telegraf
[2]: https://github.com/hashicorp/consul-template

repository: bdclark/docker-telegraf-consul

repo_name: bdclark/docker-telegraf-consul


text:
# Hot Reload

"Hot Reload" is not simply reloading the page when you edit a file. With hot reload enabled, when you edit a `*.vue` file, all instances of that component will be swapped in **without reloading the page**. It even preserves the current state of your app and these swapped components! This dramatically improves the development experience when you are tweaking the templates or styling of your components.

![hot-reload](http://blog.evanyou.me/images/vue-hot.gif)

When scaffolding the project with `vue-cli`, Hot Reload is enabled out-of-the-box.

repository: HelloZJW/mpvue-loader

repo_name: HelloZJW/mpvue-loader


text:
# VERITAS ROOT-generic

Generic VERITAS docker images for development and testing.

Baseimages from: https://github.com/root-project/root-docker

## Building

Use the build script `../build_all.sh`.

## Running

Run the image and provide a bash environment:

```
$ docker run --rm -it -v "$(pwd):/data" vts-image bash
```

Replace `vts-image` by the corresponding image name.

## Development image

Expect code outside of the images.

gha_language: Dockerfile


text:
# Instructions for deploying to Windows

- Obtain the Windows site's publishing credentials
- Define the `sitename`, `username` and `password` environment variables in a Windows command-prompt
```cmd
    set sitename=<name of site>
    set username=<username>
    set password=<password>
```
Example:
```cmd
    set username=$my-testsite1
    set password=my-testsite1-password
    set sitename=my-testsite1
```
- Now, run the following script to update your site to use custom Kudu bits
```cmd
    deploy.cmd
```
- Done! Your site will now be running with the custom Kudu bits we just deployed in the above steps.

repository: andxu/onedeploy

repo_name: andxu/onedeploy


text:
+++
title = "Your father Abraham saw my Day and was glad"
description = "Lenten Reflections 2020"
date = "2020-04-02"
categories = [
    "Thursday",
]
menu = "main"
+++

```
Thursday of the Fifth Week of Lent Year A 2020

Genesis 17:3-9
Psalms 105:4-5, 6-7, 8-9
John 8:51-59
```

In last Monday’s gospel reading, the religious leaders were ready to stone a woman whom they had brought to Jesus. In this morning’s gospel reading, the same group pick up stones in order to stone Jesus. They wanted to stone the woman because she had sinned by committing adultery; they wanted to stone Jesus because of the claims that he was making for himself, such as his claim that he existed before Abraham was born. This was considered the sin of blasphemy.

The notion of someone being stoned to death is abhorrent to us. It still happens in those few places where Sharia Law is operative. Yet, thankfully, we consider such behaviour to belong to a past age. It wasn’t uncommon in the time of Jesus. You may recall that Stephen, the first Christian martyr, was stoned to death.

In today’s gospel reading, Jesus’ opponents wanted to inflict the same fate on him, ‘at this they picked up stones to throw at him’, presumably with a view to killing him. It was a precursor of Jesus’ crucifixion. What aroused such deadly anger from some people towards Jesus were the claims he was making for himself. There are two powerful claims Jesus makes for himself in today’s gospel, one at the beginning and the other at the end of the reading, ‘whoever keeps my word will never see death’, and ‘before Abraham ever was, I am’.

Jesus was claiming to pre-exist Abraham and declaring that whoever believed in him would exist beyond this earthly life. They would never experience ultimate death. These claims, for believers, rather than arousing anger bring great consolation.

According to John’s gospel, Jesus pre-existed the universe. ‘In the beginning was the Word’. He came from another world, the world above, into this world. The Word became flesh.  His journey from this world back to his heavenly Father was a journey that all who believes in him would also travel. This is good news which brings meaning and joy to our lives.

## Reflect
Reflect on this statement:  “Either Jesus is who he says he is, or he is  lying. There is no middle ground.” Where do you stand?

## Prayer

God of mercy,
help us today to grow in your likeness, that we who sinned in Adam may rise again in Christ.
Let your word be a lamp to guide us,
that we may live the truth
and grow always in your love.
Teach us to be faithful in seeking the common good for your sake,
that your light may shine on the whole human family by means of your Church.
Touch our hearts to seek your friendship more and more,
and to make amends for our sins against your wisdom and goodness.


text:
# ym-api

[![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/phone2action/ym-api/badges/quality-score.png?b=dev-master)](https://scrutinizer-ci.com/g/phone2action/ym-api/?branch=dev-master) [![Build Status](https://scrutinizer-ci.com/g/phone2action/ym-api/badges/build.png?b=dev-master)](https://scrutinizer-ci.com/g/phone2action/ym-api/build-status/dev-master) [![Code Coverage](https://scrutinizer-ci.com/g/phone2action/ym-api/badges/coverage.png?b=dev-master)](https://scrutinizer-ci.com/g/phone2action/ym-api/?branch=dev-master)

# Your Membership API Client for PHP
### This package in a work in progress, we currently use this package for development of an integration with YourMembership.

This package implements a PHP wrapper to work with http://www.yourmembership.com/company/api-reference/

### Laravel Installation (5.1+)

No Support for Versions below 5.1 (5.0 Untested)

Require this package with composer by adding the following to your composer file:

```json
{
"require": {
    "phone2action/ym-api": "dev-master"
},
"repositories": [

        {
            "type": "vcs",
            "url": "https://github.com/phone2action/ym-api"
        }
    ]
}
```
After updating composer, add the service provider to the `providers` array in `config/app.php`

```php
P2A\YourMembership\YourMembershipServiceProvider::class,
```

You can publish the config file for this package
```bash
php artisan vendor:publish --provider="P2A\YourMembership\YourMembershipServiceProvider"
```

### Usage

#### Laravel
```php
$client = app(P2A\YourMembership\YourMembershipClient::class,[$apiKey,$saPasscode]);
```

#### Other
Instantiate the client

```
$guzzleClient = new \GuzzleHttp\Client();
$client = new P2A\YourMembership\YourMembershipClient($guzzleClient, $apiKey, $saPasscode)
```

Make API calls using this client

```php
$response = $client->makeCall('Session.Create')->toArray();
echo $response['SessionID'];

$response = $client->makeCall('Session.Create')->toObject();
echo $response->SessionID;
```

repository: ABOGABOGI/ym-api

repo_name: ABOGABOGI/ym-api


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

title: Noisy Multiobjective Black-Box Optimization Using Bayesian Optimization
subtitle: ''
summary: ''
authors:
- HongyanWang
- HuaXu
- YuanYuan
- JunhuiDeng
- XiaominSun
tags:
- '"gaussian noise"'
- '"gaussian process"'
- '"ParEGO"'
- '"black-box optimization"'
- '"expensive multiobjective optimization"'
categories: []
date: '2019-01-01'
lastmod: 2020-09-19T21:55:29+08:00
featured: false
draft: false

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

# Projects (optional).
#   Associate this post with one or more of your projects.
#   Simply enter your project's folder or file name without extension.
#   E.g. `projects = ["internal-project"]` references `content/project/deep-learning/index.md`.
#   Otherwise, set `projects = []`.
projects: []
publishDate: '2020-09-19T13:55:28.463251Z'
publication_types:
- 1
abstract: Expensive black-box problems are usually optimized by Bayesian Optimization
  (BO) since it can reduce evaluation costs via cheaper surrogates. The most popular
  model used in Bayesian Optimization is the Gaussian process (GP) whose posterior
  is based on a joint GP prior built by initial observations, so the posterior is
  also a Gaussian process. Observations are often not noise-free, so in most of these
  cases, a noisy transformation of the objective space is observed. Many single objective
  optimization algorithms have succeeded in extending efficient global optimization
  (EGO) to noisy circumstances, while ParEGO fails to consider noise. In order to
  deal with noisy expensive black-box problems, we extending ParEGO to noisy optimization
  according to adding a Gaussian noisy error while approximating the surrogate. We
  call it noisy-ParEGO and results of S-metric indicate that the algorithm works well
  on optimizing noisy expensive multiobjective black-box problems.
publication: '*Proceedings of the Genetic and Evolutionary Computation Conference
  Companion*'
url_pdf: https://doi.org/10.1145/3319619.3321898
doi: 10.1145/3319619.3321898
---

url: https://raw.githubusercontent.com/MFYDev/THUIARWeb/bdc2d227d26c552de594f6c64360e0c9c0c6f89f/content/zh/publication/Noisy Multiobjective Black-Box Optimization Using Bayesian Optimization/index.md

repository: MFYDev/THUIARWeb

gha_language: TeX

repo_name: MFYDev/THUIARWeb


text:
---
name: C-PAC vX.X.X ― [short name/label]
about: Submit run information for a completed or attempted C-PAC pipeline.
title: C-PAC vX.X.X ― [short name/label]
labels: log
assignees: ''

---

<!--
Toggle between the 'write' and 'preview' tabs for markdown rendering.
-->

## C-PAC Run Info

|                     |                                                                                |
| :------------------ | :-------------------------------------------------------------------------------------- |
| **Description**     | replace this with a brief description of your pipeline run                              |
| **Version**            | replace this with the C-PAC version used                                          |
| **Container**            | replace this with the container tag (Docker/Singularity) you used                                          |
| **System**            | what system did you run on? local machine (Linux/MacOS)? server/cluster? AWS? Flywheel? etc.                                          |
| **Data Size**  | how many TRs is your data? (if BOLD)                          |
| **Results**     | did the pipeline complete successfully? any problems? any missing outputs?                              |

**Include:**
- [ ] Run Command:

||
| :-------------------------------------------------------------------------------------- |
| (the command-line command you used to start the run)                                                     |

- [ ] Pipeline Config (can drag file directly into issue)
- [ ] Data Config (can drag file directly into issue)

**Developers only:**
- [ ] Default Pipeline Diff:

||
| :-------------------------------------------------------------------------------------- |
| (print-out from [cpac_pipe_diff.py](https://github.com/sgiavasis/CPAC_regtest_pack/blob/master/cpac_pipe_diff.py))                                                     |

- [ ] Screenshots of brain extraction and registration wireframe overlays from QC pages (if available):

||
| :-------------------------------------------------------------------------------------- |
| screenshots here                                                    |

- [ ] Node timing information:

||
| :-------------------------------------------------------------------------------------- |
| (print-out from [callback_log_time_parse.py](https://github.com/sgiavasis/CPAC_regtest_pack/blob/master/callback_log_time_parse.py))                                                     |

- [ ] Extracted time series 1D and nuisance regressors 1D correlations against previous version or some benchmark (can use [corr_two_1D.py](https://github.com/sgiavasis/CPAC_regtest_pack/blob/master/corr_two_1D.py) but heatmaps or other visualizations are good too):

||
| :-------------------------------------------------------------------------------------- |
| correlations here                                                    |

repository: shnizzedy/brainlife-C-PAC

repo_name: shnizzedy/brainlife-C-PAC


text:
init

## ACTION: init
**PARAMETERS:**
* __sender__ is an eosio account name.
* __receiver__ is an eosio account name.
* __arb__ is an eosio account name.
* __expires__ The date/time after which the escrow amount can be refunded by the sender.
* __memo__ is a memo to send as the eventual transfer memo at the end of the escrow contract.
* __ext_reference__ is a reference to to external id held my another contract or entity as opposed to the internal auto-incrementing key.

**INTENT** The intent of init is to create an empty escrow payment agreement for safe and secure funds transfer protecting both sender and receiver for a determined amount of time.
#### Warning: This action will store the content on the chain in the history logs and the data cannot be deleted later so therefore should only store a unidentifiable hash of content rather than human readable content.

    transfer

## ACTION: transfer
**PARAMETERS:**
* __from__ is an eosio account name.
* __to__ is an eosio account name.
* __quantity__ is an eosio asset name.
* __memo__ is a string that provides a memo for the transfer action.

**INTENT:**
The intent of transfer is to listen and react to the eosio.token contract's transfer action and ensure the correct parameters have been included in the transfer action.
##Warning: This action will store the content on the chain in the history logs and the data cannot be deleted later.

approve

## ACTION: approve
**PARAMETERS:**
* __key__ is a unique identifying integer for an escrow entry.
* __approver__ is an eosio account name.

**INTENT:**
The intent of approve is to approve the release of funds to the intended receiver.  Only the arbitrator or the sender can call this action, the receiver is assumed to always approve of the release of funds.
 ####Warning: This action will store the content on the chain in the history logs and the data cannot be deleted later.

 disapprove

## ACTION: disapprove
**PARAMETERS:**
* __key__ is a unique identifying integer for an escrow entry.
* __disapprover__ is an eosio account name.

**INTENT:**
The intent of disapprove is to disapprove the release of funds to the intended receiver. Only the appointed arbitrator can call this action and the result will be that the funds contained in the escrow will be returned to the sender, less any arbitration fee.
 ####Warning: This action will store the content on the chain in the history logs and the data cannot be deleted later.

  refund

## ACTION: refund

**PARAMETERS:**
* __key__ is a unique identifying integer for an escrow entry.

**INTENT:** The intent of refund is to return the escrowed funds back to the original sender. This action can only be run after the contract has passed the intended expiry time.
**TERM:** This action lasts for the duration of the time taken to process the transaction.

  cancel

## ACTION: cancel

**PARAMETERS:**
* __key__ is a unique identifying integer for an escrow entry.

**INTENT:** The intent of cancel is to cancel an escrow agreement. This action can only be performed by the sender as long as no funds have already been transferred for the escrow agreement. Otherwise they would need to wait for the expiry time and then use the refund action.
**TERM:** This action lasts for the duration of the time taken to process the transaction.

  clean

## ACTION: clean

**INTENT:** The intent of clean is remove all existing escrow agreements for developer purposes. This can only be run with _self permission of the contract which would be unavailable on the main net once the contract permissions are removed for the contract account.
**TERM:** This action lasts for the duration of the time taken to process the transaction.

repository: paplooo/eosdac-contracts

repo_name: paplooo/eosdac-contracts