text:
# UGE_MONITORING

## ugetop

ugetop provides a 'top'-like view of jobs that are queued on UGE.

Run it like so:

    ./ugetop [refresh_seconds=30]

An example view is:

          USER           QUEUE         r        qw       Eqw        dr        dt
      nshoresh       [pending]         0      8197         0         0         0
       *bhaas*       [pending]         0      1542         0         0         0
        cychen       [pending]         0      6943         0         0         0
       bcleary       [pending]         0      2110         0         0         0
        jlevin       [pending]         0       342         0         0         0
        rkolde       [pending]         0       324         0         0         0
       *bhaas*           short       286         0         0         0         0
      nshoresh            long       262         0         0         0         0
        ljerby       [pending]         0       196         0         0         0
       gustavo       [pending]         0       106         0         0         0
        cychen           short       102         0         0         0         0
       bcleary            long       100         0         0         0         0
        lyping       [pending]         0        68         0         0         0
            li       [pending]         0        65         0         0         0
      mzekavat       [pending]         0        59         0         0         0
      rcdelros            long        50         0         0         0         0
       cfreije       [pending]         0         0         7         0         0
          phil       [pending]         0        41         0         0         0
      veerapen            long        40         0         0         0         0
       gustavo            long        38         0         0         0         0
        Totals   -------------      1322     20117         8         0         0

The top 20 largest jobs are shown in addition to any that you (the ${USER}) have running.  Your jobs will show up with '*' highlighting them.

Running jobs show up in the corresponding queue (eg. short, long).  Those not running are grouped as' [pending]'.

To stop 'ugetop', click ctrl-c


text:
---
layout: post
title:      "Downloadable content via Rails"
date:       2019-09-20 18:49:00 +0000
permalink:  downloadable_content_via_rails
---

Today I'm going to rehash my theme from a couple weeks ago, don't stop learning, and cover the topic of making content downloadable. Through the Flatiron coursework, this was one of those things not touched on that I quickly found a need for. Making a link stream data in Rails is super easy!

## send_data
For what I was doing, I wanted users to be able to click a link and download a pdf. I covered previoiusly how to generate the pdf, as well as attach the pdf to an email. Now let's look at the code to allow the user to download it. For starters, I setup a route:
```
./config/routes.rb

...

get '/forms/:id/download', to: 'forms/download', as: 'form_download'

...

```

Simple enough start. Next, add the method into the controller:

```
class FormsController << ApplicationController

...

def download
		pdf_path = generate_pdf(params[:id])

		file = File.open(Rails.root.join('public', 'uploads', pdf_path), "rb")
		contents = file.read
		file.close

		File.delete(pdf_path) if File.exist?(pdf_path)

		send_data(contents, :filename => "Form_data_#{params[:id]}.pdf")
	end

	...
```

Let's breakdown what happens here.
1) Create a pdf using the generate_pdf method. The return value of generate_pdf (assuming it was successful), is the path to the new file.
2) Open the file in read-byte mode ('rb') and store it's value into a variable, `contents`
3) Close the file and delete it. Adding the conditional `if` on the `File.delete` insures that nothing will crash if the file happens to not be there.
4) Send the data, using `#send_data` with the filename "Form_data_(form_id).pdf"

## Seems too easy
And really, it is. Let's take a closer look though at what Rails is doing in the background to make this happen. First off, [`#send_data`](https://apidock.com/rails/ActionController/Streaming/send_data):

```
# File actionpack/lib/action_controller/metal/streaming.rb, line 112
      def send_data(data, options = {}) #:doc:
        send_file_headers! options.dup
        render options.slice(:status, :content_type).merge(:text => data)
      end
```

Breaking this down, we can see first line duplicates the options, and passes it to a method called `#send_file_headers!`. One point of interest here is that it is using `.dup` rather than just sending it options. Reason for that is `#send_file_headers!` makes changes to the `options` object passed to it, that will change the original `options`. In other words, it might be a bit destructive. Let's see what that looks like, firing up `irb`, give this a go:

```
2.6.3 :001 > my_props = {:name => 'brad', :age => 39}
 => {:name=>"brad", :age=>39}
2.6.3 :002 > def update_with_height(prop)
2.6.3 :003?>   prop.update(:height => 72)
2.6.3 :004?>   end
 => :update_with_height
2.6.3 :005 > my_props_with_height = update_with_height(my_props)
 => {:name=>"brad", :age=>39, :height=>72}
2.6.3 :006 > my_props
 => {:name=>"brad", :age=>39, :height=>72}
```
Because I didn't send a duplicate of `my_props` it was updated destructively by the method. Had I sent `my_props.dup` instead, my return value would have been the same, but `my_props` would have remained unchanged.

#### Functional programming... a quick side not
This is one important aspect of functional programming, and that's that functions or methods that are called are not destructive to the original values that were passed to them. Whether that means passing a duplicate object value in Ruby, or utilizing `.slice` in JS rather than `.shift/.unshift/.pop/.push`, the main point is that the functions don't have any side effects. They always return the same value when passed the same initial parameters and they are not destructive. No weird side effects!

## Back to our originally scheduled program
So the following line is a call to `render`. Again, being non-destructive but only passing the necessary info, `.slice` gets called on our options to only send the relevant properties. This leaves `options` untouched. Going back to my previous example:

```
2.6.3 :011 > my_props_with_height.slice(:age)
 => {:age=>39}
2.6.3 :012 > my_props_with_height
 => {:name=>"brad", :age=>39, :height=>72}
```

`my_props_with_height` doesn't get changed when `.slice` is used. The data that is sent (`contents` variable in the case of my code), is sent as `:text`.

## So how did the browser know to download rather than render?
Ahh, so that actually happened because of the first method that I glossed over, `#send_file_headers!`. Turns out, if you crack open the code for it, one of the things you'll see is a global variable:

`DEFAULT_SEND_FILE_OPTIONS = {
      :type         => 'application/octet-stream'.freeze,
      :disposition  => 'attachment'.freeze,
    }.freeze`

		The user passed `options` get merged with `DEFAULT_SEND_FILE_OPTIONS` via `.merge` (remember, don't have any weird side effects). That `:dispoisition` key with a value of attachment, that's what tells the browser specifically to download the content as a file, rather than display it. The `:type` tells the browser, I don't really know what kind of file this is, but it will be binary data. It's best to specify in your options what kind of data you are sending (ie `application/pdf` would have been good for my example).

		RoR send_file_headers: https://apidock.com/rails/ActionController/Streaming/send_file_headers%21
		RoR send_data: https://apidock.com/rails/ActionController/Streaming/send_data

branch_name: refs/heads/master

extension: markdown

license_type: permissive


text:
# @redux-requests/graphql

[![npm version](https://badge.fury.io/js/%40redux-requests%2Fgraphql.svg)](https://badge.fury.io/js/%40redux-requests%2Fgraphql)
[![Build Status](https://travis-ci.org/klis87/redux-requests.svg?branch=master)](https://travis-ci.org/klis87/redux-requests)
[![Coverage Status](https://coveralls.io/repos/github/klis87/redux-requests/badge.svg?branch=master)](https://coveralls.io/github/klis87/redux-requests?branch=master)
[![Known Vulnerabilities](https://snyk.io/test/github/klis87/redux-requests/badge.svg)](https://snyk.io/test/github/klis87/redux-requests)
[![lerna](https://img.shields.io/badge/maintained%20with-lerna-cc00ff.svg)](https://lernajs.io/)

GraphQL driver for redux-requests, declarative AJAX requests and automatic network state management for single-page applications

## Installation

To install the package, just run:

```
$ npm install @redux-requests/graphql
```

or you can just use CDN: `https://unpkg.com/@redux-requests/graphql`.

## Usage

For usage, see [redux-requests docs](https://redux-requests.klisiczynski.com).

## Licence

MIT

license: MIT

extension: md

gha_language: JavaScript

gha_license_id: MIT


text:
---
layout: default
---

# 1993-02-05 - Re: `Sunday Times' article on GSM changes

## Header Data

From: gnu (John Gilmore)

To<EMAIL_ADDRESS>(Perry E. Metzger)

Message Hash: 71a5c5b55849fc0353bd2ab14ae32ea7d7efbdd7553d1905880b8c163c17e4e1

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1993-02-05 19:17:05 UTC

Raw Date: Fri, 5 Feb 93 11:17:05 PST

## Raw message

```
{% raw  %}From: gnu (John Gilmore)
Date: Fri, 5 Feb 93 11:17:05 PST
To<EMAIL_ADDRESS>(Perry E. Metzger)
Subject: Re: `Sunday Times' article on GSM changes
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

> > ... voice data requires about 64Khz...

Actually I think you meant 64 kbits/sec.

> Just as a point of information, you can compress voice into 4kbit/sec
> without any real loss of quality.

I wouldn't say "without any real loss of quality".  I have an AT&T secure
phone on loan for evaluation (attendees at the last Mt. View cypherpunks
meeting have played with it).  It compresses voice to 4800 b/s then encrypts
it and uses a stripped down V.32 modem to send it.

The voice is intelligible on the other end, but there is definitely a
loss of quality.  It sounds like you are talking through the bubbler
in an aquarium (underwater).  But it is possible to recognize
someone's voice on the other end, at least when you already know who
it is.  "No real loss of quality" goes way too far.

By the way, I have public domain (federally written) code that
compresses voice down to this size.  It's called CELP, Code Excited
Linear Prediction.  The only catch is the code they wrote runs much
slower than realtime (on workstations).  My guess is that there are
significant speedups that we could make by hacking on it and running
gprof.  Van Jacobson has done some work on this, but his policy seems
to be to sit on anything good for two to three years before releasing
it.  Anyone interested in beating him to the net with something that
would compress voice (or voicemail) in realtime on a 486 or a SPARC?

	John

{% endraw %}
```

## Thread

+ Return to [February 1993](/archive/1993/02)

+ Return to "[gnu (John Gilmore)](/authors/gnu_john_gilmore_)"
+ Return to "[Johan Helsingius <julf@penet.FI>](/authors/johan_helsingius_julf_at_penet_fi_)"
+ Return to<EMAIL_ADDRESS>(Perry E. Metzger)](/authors/pmetzger_at_shearson_com_perry_e_metzger_)"

+ 1993-02-05 (Fri, 5 Feb 93 10:53:24 PST) - [Re: `Sunday Times' article on GSM changes](/archive/1993/02/8e53052c887aba7cd02aad3630dcf315cf20c027fb1f8c93959f1b9c9d212bd7) -<EMAIL_ADDRESS>(Perry E. Metzger)_
  + 1993-02-05 (Fri, 5 Feb 93 11:17:05 PST) - Re: `Sunday Times' article on GSM changes - _gnu (John Gilmore)_
  + 1993-02-05 (Fri, 5 Feb 93 12:22:44 PST) - [Re: `Sunday Times' article on GSM changes](/archive/1993/02/3bd4d51bc052336de36743b6e748317daaee221ef2aae55f6551533b0eb02e2e) - _Johan Helsingius<EMAIL_ADDRESS>


text:
# NewsFlow

A co-evolving multilayer model of the flow of the news.

For further details about the model, its implementation, advantages and limitations, and empirical results, please refer to the original paper [[1]](#1).

## Model and implementation

## Prerequisites
The packages [`python-igraph`](https://igraph.org/python/) (version 0.7.1) and [`cyrandom`](https://pypi.org/project/cyrandom/) (version 0.3.1) must be installed in order to run the `NewsFlow`, which can be easily done with the [`pip`](https://pip.pypa.io/en/stable/) command:
```
$ pip install python-igraph
$ pip install cyrandom
```
(for troubleshooting, refer to the [python-igraph user manual](https://igraph.org/python/#pyinstall)).

## Installing
First, clone the git repository:
```
$ git clone https://github.com/ikicab/NewsFlow/
```
Then navigate to the downloaded folder and type the following commands into the terminal:
```
$ python setup.py build_ext --inplace
$ cython -a NewsFlow.pyx
```

## Usage

### Input parameters
The algorithm accepts the following input parameters – note that only the input graph `g`, the initial number `F0` of consumers of false news, the news-alignment rate `eta`, and the spreading rate of false news `lambda_F` are mandatory.

| Parameter name | Variable type | Description | Default value (if applicable) |
| --------- | ----------- | ----------- |----------- |
| `g` | `igraph.Graph` | population layer in the form of an (unweighted undirected) graph |
| `F0` | `int` | initial number of consumers of false news |
| `eta` | `double` | rate of news-alignment (news-rewiring) |
| `lambda_F` | `double` | spreading rate of false news |
| `lambda_T` | `double` | spreading rate of true news | `1`
| `M` | `int` | number of media outlets that disseminate false/true news content; in total, there are `2*M` news providers | `10`
| `t_max` | `int` | upper limit on the simulation time (ignored if `0`) | `0`
| `window_size` | `int` | length of the sliding window over which the sample variance in the number of unbalanced (active) edges/polarised news consumers is computed (ignored if `0`) | `0` or `len(g.vs)` if `t_max == 0`
| `tol` | `double` | tolerance on the sliding-window variance (ignored if `window_size == 0`) | `0.02`
| `sfreq` | `int` | state-saving frequency | `0`

### Output parameters
Output parameters depend on the choice of `sfreq`; see below.

| Applicable if `sfreq` | Parameter name | Variable type | Description |
| --------- | --------- | ----------- | ----------- |
| `== 0` | `time_range` | `list` | time-step evolution
| `== 0` | `list_polarised` | `list` | detailed time evolution of the number of polarised individuals
| `== 0` | `list_rhoF` | `list` | detailed time evolution of the number of consumers of false news
| `== 0` | `list_FT_edges` | `list` | detailed time evolution of the number of unbalanced (active) edges
| `< 0` | `v_polarised` | `int` | final number of polarised individuals
| `< 0` | `rhoF` | `int` | final number of consumers of false news in the population
| `< 0` | `nFT_edges` | `int` | final number of unbalanced (active) edges
| `> 0` | `list_rhoF` | `list` | detailed time evolution (with a sampling frequency of `sfreq`) of the number of consumers of false news
| `> 0` | `X_Ymedia` | `dict` | detailed time evolution (with a sampling frequency of `sfreq`) of the number of media outlets that disseminate `Y` news content subscribed to by consumers of `X` news (with `X` and `Y` standing for true/false)
| `> 0` | `Xmedia_Y` | `dict` | detailed time evolution (with a sampling frequency of `sfreq`) of the number of consumers of `Y` news subscribed to media outlets that disseminate `X` news content (with `X` and `Y` standing for true/false)

### Visualisation
A selection of dedicated visualisation tools may be found in the accompanying `Python` script `VisualTools` (refer also to the [Tutorial](https://nbviewer.jupyter.org/github/ikicab/NewsFlow/blob/master/Tutorial.ipynb)).

## Tutorial
See the [Tutorial](https://nbviewer.jupyter.org/github/ikicab/NewsFlow/blob/master/Tutorial.ipynb) for more help and examples.

## References
[1]
B. Ikica, _Co-evolution of the Multilayer News Flow. In preparation; a detailed overview can be found [here](https://repozitorij.uni-lj.si/IzpisGradiva.php?id=113311&lang=eng) (refer to pages 161–199)._

The figure above was prepared with the [`LaTeX`](https://www.latex-project.org/) drawing package [`tikz-network`](https://github.com/hackl/tikz-network).

repository: ikicab/NewsFlow

gha_language: Jupyter Notebook

repo_name: ikicab/NewsFlow


text:
# Tableau Key Performance Indicators

###### Last updated February 24, 2021

:::

##### Overview

Key Performance Indicators (KPIs) are defined as "critical (key) indicators of progress toward an intended result".
On our accelerators, these KPIs should provide an entry point into the information on a page.
They allow users to make an immediate judgement about the state of the information being tracked, and provide guidance for areas of further investigation.

KPIs are so ubiquitous that they have become a established convention for data-savvy users.
An [eye-tracking study conducted by Tableau](https://www.tableau.com/about/blog/2017/6/eye-tracking-study-5-key-learnings-data-designers-everywhere-72395) in 2017 revealed that big numbers are one of first elements of a dashboard that viewers are drawn to.
It's important for us to take advantage of this convention as a way to guide users through the information we are presenting.

![KPI Tile](./assets/analytics/tableau/kpitile.png "KPI Tile")

:::

:::

##### Layout

KPI Metrics follow all the general standards for tiles as defined in the [Foundations section](/analytics/tableau-foundations).
Refer to that **Tile Header** and **Divider** sections of that page for specific parameters to apply to the top of the KPI.

The content of the KPI should be centered in tile.

The main KPI value should be formatted as:
- **Font**: Tableau Light
- **Font size**: 24pt
- **Font color**: offblack `#333333`
KPI metrics often leverage a second line to indicate trend or sources. A secondary metric should be formatted as:
- **Font**: Tableau Book
- **Font size**: 10pt
- **Font color**: offblack `#333333`

Arrows or text colors indicating positive trends should be set to
- **Color**: green `#00a859`

For negative trends, use
- **Color**: red `#f13c45`

But never rely solely on color to indicate a positive or negative trend, either text or iconography should also indicate the trend.

:::

:::

##### Info Tooltip

Every KPI metric should include an info tooltip in its header.
Refer to the [Foundations section](/analytics/tableau-foundations) for information on how to configure it.
The info tooltip should provide a description of specifically what the metric is meant to indicate, and how it is calculated (equations can be useful).

:::

:::

##### Drill-down

A drill-down button should generally be included with every KPI metric header as well.
The purpose of the drill-down button is to allow the user to look into the raw data used to calculate the metric.
It serves as an opportunity for validation and additional exploration.
Most accelerators will want to include a "Measure Explorer" page similar to that of our decision support application, [Leading Wisely](https://www.healthcatalyst.com/product/leading-wisely/).
The Measure Explorer tab is what the KPI drill-down will typically link to with the particular metric selected.
Refer to the template for an example implementation of a Measure Explorer page.

:::

branch_name: refs/heads/dev

gha_language: TypeScript


text:
---
author: "sc-ram"
date: 2021-03-21
title: "GitHub Actions FTW"
---
Using GitHub Actions with Hugo to build this site

Making use of GitHub actions in combination with Hugo is a nice and easy way to build static web pages.
The following resources helped to make this really easy:
- [GH actions by peaceiris](https://github.com/peaceiris/actions-gh-pages)
- [Hermit Template](https://github.com/Track3/hermit)
- [Nice blog as baseline](https://blog.kye.dev/hugo-github-pages-actions/)

branch_name: refs/heads/main


text:
---
title: Client API | ldapjs
---

# ldapjs Client API

<div class="intro">

This document covers the ldapjs client API and assumes that you are familiar
with LDAP. If you're not, read the [guide](guide.html) first.

</div>

# Create a client

The code to create a new client looks like:

    var ldap = require('ldapjs');
    var client = ldap.createClient({
      url: ['ldap://<IP_ADDRESS>:1389', 'ldap://<IP_ADDRESS>:1389']
    });

    client.on('error', (err) => {
      // handle connection error
    })

You can use `ldap://` or `ldaps://`; the latter would connect over SSL (note
that this will not use the LDAP TLS extended operation, but literally an SSL
connection to port 636, as in LDAP v2). The full set of options to create a
client is:

|Attribute      |Description                                                |
|---------------|-----------------------------------------------------------|
|url            |A string or array of valid LDAP URL(s) (proto/host/port)   |
|socketPath     |Socket path if using AF\_UNIX sockets                      |
|log            |A compatible logger instance (Default: no-op logger)       |
|timeout        |Milliseconds client should let operations live for before timing out (Default: Infinity)|
|connectTimeout |Milliseconds client should wait before timing out on TCP connections (Default: OS default)|
|tlsOptions     |Additional options passed to TLS connection layer when connecting via `ldaps://` (See: The TLS docs for node.js)|
|idleTimeout    |Milliseconds after last activity before client emits idle event|
|strictDN       |Force strict DN parsing for client methods (Default is true)|
|reconnect      |Try to reconnect when the connection gets lost (Default is false)|

### url
This parameter takes a single connection string or an array of connection strings
as an input. In case an array is provided, the client tries to connect to the
servers in given order. To achieve random server strategy (e.g. to distribute
the load among the servers), please shuffle the array before passing it as an
argument.

### Note On Logger

A passed in logger is expected to conform to the [Bunyan](https://www.npmjs.com/package/bunyan)
API. Specifically, the logger is expected to have a `child()` method. If a logger
is supplied that does not have such a method, then a shim version is added
that merely returns the passed in logger.

Known compatible loggers are:

+ [Bunyan](https://www.npmjs.com/package/bunyan)
+ [Pino](https://www.npmjs.com/package/pino)

## Connection management

As LDAP is a stateful protocol (as opposed to HTTP), having connections torn
down from underneath you can be difficult to deal with. Several mechanisms
have been provided to mitigate this trouble.

### Reconnect

You can provide a Boolean option indicating if a reconnect should be tried. For
more sophisticated control, you can provide an Object with the properties
`initialDelay` (default: `100`), `maxDelay` (default: `10000`) and
`failAfter` (default: `Infinity`).
After the reconnect you maybe need to [bind](#bind) again.

## Client events

The client is an `EventEmitter` and can emit the following events:

|Event          |Description                                               |
|---------------|----------------------------------------------------------|
|error          |General error                                             |
|connectRefused |Server refused connection. Most likely bad authentication |
|connectTimeout |Server timeout                                            |
|connectError   |Socket connection error                                   |
|setupError     |Setup error after successful connection                   |
|socketTimeout  |Socket timeout                                            |
|resultError    |Search result error                                       |
|timeout        |Search result timeout                                     |
|destroy        |After client is disconnected                              |
|end            |Socket end event                                          |
|close          |Socket closed                                             |
|connect        |Client connected                                          |
|idle           |Idle timeout reached                                      |

## Common patterns

The last two parameters in every API are `controls` and `callback`. `controls`
can be either a single instance of a `Control` or an array of `Control` objects.
You can, and probably will, omit this option.

Almost every operation has the callback form of `function(err, res)` where err
will be an instance of an `LDAPError` (you can use `instanceof` to switch).
You probably won't need to check the `res` parameter, but it's there if you do.

# bind
`bind(dn, password, controls, callback)`

Performs a bind operation against the LDAP server.

The bind API only allows LDAP 'simple' binds (equivalent to HTTP Basic
Authentication) for now. Note that all client APIs can optionally take an array
of `Control` objects. You probably don't need them though...

Example:

    client.bind('cn=root', 'secret', function(err) {
      assert.ifError(err);
    });

# add
`add(dn, entry, controls, callback)`

Performs an add operation against the LDAP server.

Allows you to add an entry (which is just a plain JS object), and as always,
controls are optional.

Example:

    var entry = {
      cn: 'foo',
      sn: 'bar',
      email<EMAIL_ADDRESS><EMAIL_ADDRESS>      objectclass: 'fooPerson'
    };
    client.add('cn=foo, o=example', entry, function(err) {
      assert.ifError(err);
    });

# compare
`compare(dn, attribute, value, controls, callback)`

Performs an LDAP compare operation with the given attribute and value against
the entry referenced by dn.

Example:

    client.compare('cn=foo, o=example', 'sn', 'bar', function(err, matched) {
      assert.ifError(err);

      console.log('matched: ' + matched);
    });

# del
`del(dn, controls, callback)`

Deletes an entry from the LDAP server.

Example:

    client.del('cn=foo, o=example', function(err) {
      assert.ifError(err);
    });

# exop
`exop(name, value, controls, callback)`

Performs an LDAP extended operation against an LDAP server. `name` is typically
going to be an OID (well, the RFC says it must be; however, ldapjs has no such
restriction).  `value` is completely arbitrary, and is whatever the exop says it
should be.

Example (performs an LDAP 'whois' extended op):

    client.exop('<IP_ADDRESS>.4.1.4<IP_ADDRESS>', function(err, value, res) {
      assert.ifError(err);

      console.log('whois: ' + value);
    });

# modify
`modify(name, changes, controls, callback)`

Performs an LDAP modify operation against the LDAP server.  This API requires
you to pass in a `Change` object, which is described below.  Note that you can
pass in a single `Change` or an array of `Change` objects.

Example:

    var change = new ldap.Change({
      operation: 'add',
      modification: {
        pets: ['cat', 'dog']
      }
    });

    client.modify('cn=foo, o=example', change, function(err) {
      assert.ifError(err);
    });

## Change

A `Change` object maps to the LDAP protocol of a modify change, and requires you
to set the `operation` and `modification`.  The `operation` is a string, and
must be one of:

| Operation | Description |
|-----------|-------------|
| replace   | Replaces the attribute referenced in `modification`.  If the modification has no values, it is equivalent to a delete. |
| add       | Adds the attribute value(s) referenced in `modification`.  The attribute may or may not already exist. |
| delete    | Deletes the attribute (and all values) referenced in `modification`. |

`modification` is just a plain old JS object with the values you want.

# modifyDN
`modifyDN(dn, newDN, controls, callback)`

Performs an LDAP modifyDN (rename) operation against an entry in the LDAP
server.  A couple points with this client API:

* There is no ability to set "keep old dn."  It's always going to flag the old
dn to be purged.
* The client code will automatically figure out if the request is a "new
superior" request ("new superior" means move to a different part of the tree,
as opposed to just renaming the leaf).

Example:

    client.modifyDN('cn=foo, o=example', 'cn=bar', function(err) {
      assert.ifError(err);
    });

# search
`search(base, options, controls, callback)`

Performs a search operation against the LDAP server.

The search operation is more complex than the other operations, so this one
takes an `options` object for all the parameters.  However, ldapjs makes some
defaults for you so that if you pass nothing in, it's pretty much equivalent
to an HTTP GET operation (i.e., base search against the DN, filter set to
always match).

Like every other operation, `base` is a DN string.

Options can be a string representing a valid LDAP filter or an object
containing the following fields:

|Attribute  |Description                                        |
|-----------|---------------------------------------------------|
|scope      |One of `base`, `one`, or `sub`. Defaults to `base`.|
|filter     |A string version of an LDAP filter (see below), or a programatically constructed `Filter` object. Defaults to `(objectclass=*)`.|
|attributes |attributes to select and return (if these are set, the server will return *only* these attributes). Defaults to the empty set, which means all attributes. You can provide a string if you want a single attribute or an array of string for one or many.|
|attrsOnly  |boolean on whether you want the server to only return the names of the attributes, and not their values.  Borderline useless.  Defaults to false.|
|sizeLimit  |the maximum number of entries to return. Defaults to 0 (unlimited).|
|timeLimit  |the maximum amount of time the server should take in responding, in seconds. Defaults to 10.  Lots of servers will ignore this.|
|paged      |enable and/or configure automatic result paging|

Responses from the `search` method are an `EventEmitter` where you will get a
notification for each `searchEntry` that comes back from the server.  You will
additionally be able to listen for a `searchReference`, `error` and `end` event.
Note that the `error` event will only be for client/TCP errors, not LDAP error
codes like the other APIs.  You'll want to check the LDAP status code
(likely for `0`) on the `end` event to assert success.  LDAP search results
can give you a lot of status codes, such as time or size exceeded, busy,
inappropriate matching, etc., which is why this method doesn't try to wrap up
the code matching.

Example:

    var opts = {
      filter: '(&(l=Seattle)(email=*@foo.com))',
      scope: 'sub',
      attributes: ['dn', 'sn', 'cn']
    };

    client.search('o=example', opts, function(err, res) {
      assert.ifError(err);

      res.on('searchEntry', function(entry) {
        console.log('entry: ' + JSON.stringify(entry.object));
      });
      res.on('searchReference', function(referral) {
        console.log('referral: ' + referral.uris.join());
      });
      res.on('error', function(err) {
        console.error('error: ' + err.message);
      });
      res.on('end', function(result) {
        console.log('status: ' + result.status);
      });
    });

## Filter Strings

The easiest way to write search filters is to write them compliant with RFC2254,
which is "The string representation of LDAP search filters."  Note that
ldapjs doesn't support extensible matching, since it's one of those features
that almost nobody actually uses in practice.

Assuming you don't really want to read the RFC, search filters in LDAP are
basically are a "tree" of attribute/value assertions, with the tree specified
in prefix notation.  For example, let's start simple, and build up a complicated
filter.  The most basic filter is equality, so let's assume you want to search
for an attribute `email` with a value of<EMAIL_ADDRESS> The syntax would be:

<EMAIL_ADDRESS>
ldapjs requires all filters to be surrounded by '()' blocks. Ok, that was easy.
Let's now assume that you want to find all records where the email is actually
just anything in the<EMAIL_ADDRESS>domain and the location attribute is set to
Seattle:

    (&(email=*@bar.com)(l=Seattle))

Now our filter is actually three LDAP filters.  We have an `and` filter (single
amp `&`), an `equality` filter `(the l=Seattle)`, and a `substring` filter.
Substrings are wildcard filters. They use `*` as the wildcard. You can put more
than one wildcard for a given string. For example you could do `(email=*@*bar.com)`
to match any email of @bar.com or its subdomains like<EMAIL_ADDRESS>
Now, let's say we also want to set our filter to include a
specification that either the employeeType *not* be a manager nor a secretary:

    (&(email=*@bar.com)(l=Seattle)(!(|(employeeType=manager)(employeeType=secretary))))

The `not` character is represented as a `!`, the `or` as a single pipe `|`.
It gets a little bit complicated, but it's actually quite powerful, and lets you
find almost anything you're looking for.

## Paging
Many LDAP server enforce size limits upon the returned result set (commonly
1000).  In order to retrieve results beyond this limit, a `PagedResultControl`
is passed between the client and server to iterate through the entire dataset.
While callers could choose to do this manually via the `controls` parameter to
`search()`, ldapjs has internal mechanisms to easily automate the process.  The
most simple way to use the paging automation is to set the `paged` option to
true when performing a search:

    var opts = {
      filter: '(objectclass=commonobject)',
      scope: 'sub',
      paged: true,
      sizeLimit: 200
    };
    client.search('o=largedir', opts, function(err, res) {
      assert.ifError(err);
      res.on('searchEntry', function(entry) {
        // do per-entry processing
      });
      res.on('page', function(result) {
        console.log('page end');
      });
      res.on('error', function(resErr) {
        assert.ifError(resErr);
      });
      res.on('end', function(result) {
        console.log('done ');
      });
    });

This will enable paging with a default page size of 199 (`sizeLimit` - 1) and
will output all of the resulting objects via the `searchEntry` event.  At the
end of each result during the operation, a `page` event will be emitted as
well (which includes the intermediate `searchResult` object).

For those wanting more precise control over the process, an object with several
parameters can be provided for the `paged` option.  The `pageSize` parameter
sets the size of result pages requested from the server.  If no value is
specified, it will fall back to the default (100 or `sizeLimit` - 1, to obey
the RFC).  The `pagePause` parameter allows back-pressure to be exerted on the
paged search operation by pausing  at the end of each page.  When enabled, a
callback function is passed as an additional parameter to `page` events.  The
client will wait to request the next page until that callback is executed.

Here is an example where both of those parameters are used:

    var queue = new MyWorkQueue(someSlowWorkFunction);
    var opts = {
      filter: '(objectclass=commonobject)',
      scope: 'sub',
      paged: {
        pageSize: 250,
        pagePause: true
      },
    };
    client.search('o=largerdir', opts, function(err, res) {
      assert.ifError(err);
      res.on('searchEntry', function(entry) {
        // Submit incoming objects to queue
        queue.push(entry);
      });
      res.on('page', function(result, cb) {
        // Allow the queue to flush before fetching next page
        queue.cbWhenFlushed(cb);
      });
      res.on('error', function(resErr) {
        assert.ifError(resErr);
      });
      res.on('end', function(result) {
        console.log('done');
      });
    });

# starttls
`starttls(options, controls, callback)`

Attempt to secure existing LDAP connection via STARTTLS.

Example:

    var opts = {
      ca: [fs.readFileSync('mycacert.pem')]
    };

    client.starttls(opts, function(err, res) {
      assert.ifError(err);

      // Client communication now TLS protected
    });

# unbind
`unbind(callback)`

Performs an unbind operation against the LDAP server.

Note that unbind operation is not an opposite operation
for bind. Unbinding results in disconnecting the client
regardless of whether a bind operation was performed.

The `callback` argument is optional as unbind does
not have a response.

Example:

    client.unbind(function(err) {
      assert.ifError(err);
    });

gha_language: Erlang


text:
# Using Combined Actions

> * Level: Beginner
>
> * Reading Time: 5 minutes
>
> * Checked with: Unity 2018.3.14f1

## Introduction

Combined Actions allow for more complex input types and in this guide we'll look at how to use Boolean input such as keyboard keys to mimic an analogue axis such as a thumbstick.

We can then take this sort of axis data and convert it into movement information or rotation information for other objects in our scene.

## Prerequisites

* [Install the Tilia.Input.UnityInputManager.Unity] package dependency in to your [Unity] project.
* [Install the Tilia.Input.CombinedActions.Unity] package dependency in to your Unity project.

## Let's Start

### Step 1

Create a new `Capsule` Unity 3D Object by selecting `Main Menu -> GameObject -> 3D Object -> Capsule`:

![Create Capsule](assets/images/CreateCapsule.png)

Right click on the `Capsule` GameObject, select `3D Object -> Cube` and change the Transform properties to:

* Position: `X = 0, Y = 0.9, Z = 0.25`
* Scale: `X = 0.1, Y = 0.1, Z = 1`

![Create Cube](assets/images/CreateCube.png)

### Step 2

Add a `Input.UnityInputManager.ButtonAction` prefab to the Unity project hierarchy by selecting `GameObject -> Tilia -> Prefabs -> Input -> UnityInputManager -> Input.UnityInputManager.ButtonAction` from the Unity main top menu.

Set the `Key Code` property in the `Unity Input Manager Button Action` component to `W`.

> To make it easier you could rename `Input.UnityInputManager.ButtonAction` GameObject to `Input.UnityInputManager.ButtonAction W` as we will have 4 different total button actions.

![Set Key Code To W](assets/images/SetKeyCodeToW.png)

> Repeat this 3 more times for the keys A, S and D.

![Duplicate Prefab](assets/images/DuplicatePrefab.png)

### Step 3

Add a `Input.CombinedActions.BooleanTo1DAxisAction` prefab to the Unity project hierarchy by selecting `GameObject -> Tilia -> Prefabs -> Input -> CombinedActions -> Input.CombinedActions.BooleanTo1DAxisAction` from the Unity main top menu.

Rename the newly created `Input.CombinedActions.BooleanTo1DAxisAction` GameObject to `Input.CombinedActions.BooleanTo1DAxisAction Horizontal`

![RenameToHorizontal](assets/images/RenameToHorizontal.png)

### Step 4

In the Axis Settings on the `Boolean To 1DAxis Action` component of the `Boolean To 1DAxis Action Horizontal` GameObject, drag and drop the `Input.UnityInputManager.ButtonAction A` GameObject into the `Negative Input` property and drag and drop the `Input.UnityInputManager.ButtonAction D` GameObject into the `Positive Input` property.

![Drag And Drop Into Horizontal Positive And Negative Parameters](assets/images/DragAndDropIntoHorizontalPositiveAndNegativeParameters.png)

### Step 5

Drag and drop another `Input.CombinedActions.BooleanTo1DAxisAction` prefab into the Unity Hierarchy window. Rename the new `Input.CombinedActions.BooleanTo1DAxisAction` GameObject to `Input.CombinedActions.BooleanTo1DAxisAction Vertical`.

![RenameToVertical](assets/images/RenameToVertical.png)

In the Axis Settings on the `Boolean To 1DAxis Action` component of the `Boolean To 1DAxis Action Vertical` GameObject, drag and drop the `Input.UnityInputManager.ButtonAction S` GameObject into the `Negative Input` property and drag and drop the `Input.UnityInputManager.ButtonAction W` GameObject into the `Positive Input` property.

![Drag And Drop Into Positive And Negative Parameters](assets/images/DragAndDropIntoVerticalPositiveAndNegativeParameters.png)

### Step 6

Create a new `Empty` Unity Object by selecting `Main Menu -> GameObject -> Create Empty` and rename it to `Movement`.

Click the `Add Component` button, then select `Transform Position Mutator` component.

This newly created `Transform Position Mutator` will be used to change the position of our `Capsule` based on our axis input.

![Add Position Mutator](assets/images/AddPositionMutator.png)

### Step 7

Drag and drop the `Capsule` GameObject into the `Target` property on the `Transform Position Mutator` component.

![Drag And Drop Capsule](assets/images/DragAndDropCapsule.png)

### Step 8

Add a `Input.CombinedActions.AxesToVector3Action` prefab to the Unity project hierarchy by selecting `GameObject -> Tilia -> Prefabs -> Input -> CombinedActions -> Input.CombinedActions.AxesToVector3Action` from the Unity main top menu.

### Step 9

Drag and drop the `Input.CombinedActions.BooleanTo1DAxisAction Horizontal` GameObject into the `Lateral Axis` property on the `Axes To Vector3` component within the `Input.CombinedActions.AxesToVector3Action` GameObject.

![Lateral Axis](assets/images/LateralAxis.png)

Drag and drop the `Input.CombinedActions.BooleanTo1DAxisAction Vertical` GameObject into the `Longitudinal Axis` property on the `Axes To Vector3 Action` component.

![Longitudinal Axis](assets/images/LongitudinalAxis.png)

Change the `Time Multiplier` property to `Delta Time` on the `Axes To Vector3 Action` component.

![Set Time Multiplier To Delta Time](assets/images/SetTimeMultiplierToDeltaTime.png)

> We want this to be `Delta Time` as we only want to multiply our axis values based on the time since the last update frame only, otherwise our movement speed would be too fast.

### Step 10

Select the `Input.CombinedActions.AxesToVector3Action` GameObject from the Unity Hierarchy window and click the `+` symbol in the bottom right corner of the `Value Changed` event parameter on the `Axes To Vector3 Action` component.

Drag and drop the `Movement` GameObject into the event listener box that appears on the `Value Changed` event parameter on the `Axes To Vector3 Action` component that displays `None (Object)`.

![Drag Movement Into Event Listener](assets/images/DragMovementIntoEventListener.png)

Select a function to perform when the `Value Changed` event is emitted. For this example, select the `TransformPositionMutator -> DoIncrementProperty` function (be sure to select `Dynamic Vector3 - DoIncrementProperty` for this example).

![Set Value Changed Function](assets/images/SetValueChangedFunction.png)

> Play the Unity scene you should now be able to control the GameObject using the W, A, S, D keys.

![Move Capsule](assets/images/MoveCapsule.png)

### Step 11

We are now going to make it possible to rotate the capsule instead.

Disable the `Movement` GameObject so our previously implemented movement functionality doesn't operate.

![Disable Movement GameObject](assets/images/DisableMovementGameObject.png)

### Step 12

Create a new `Empty` Unity Object by selecting `Main Menu -> GameObject -> Create Empty` and rename it `Rotation`.

Click the `Add Component` button, then select `Float To Vector3` component.

This newly created `Float To Vector3` component will be used to pass a rotation angle in the form of a Euler angle to rotate our `Capsule`.

![Add Float To Vector3](assets/images/AddFloatToVector3.png)

Click the `Add Component` button again, then select `Transform Euler Rotation Mutator` component.

This newly created `Transform Euler Rotation Mutator` component rotate our `Capsule` based on the rotation angle passed in from the `Float To Vector3` component.

![Add Euler Rotator](assets/images/AddEulerRotator.png)

### Step 13

Drag and drop the `Capsule` GameObject into the `Target` property on the `Transform Euler Rotation Mutator` component.

Also, change the `Mutate on Axis` property and untick the `X` and `Z` checkboxes.

> The reason we only want the Y axis turned on is because we only want to rotate around this axis to make our capsule rotate to a new facing direction in the scene.

![Drag Capsule Into Euler Mutator](assets/images/DragCapsuleIntoEulerMutator.png)

### Step 14

Select the `Rotation` GameObject from the Unity Hierarchy window and click the `+` symbol in the bottom right corner of the `Transformed` event parameter on the `Float To Vector3` component.

Drag and drop the `Rotation` GameObject into the event listener box that appears on the `Transformed` event parameter on the `Float To Vector3` component that displays `None (Object)`.

![Drag Rotation Into Event Listener](assets/images/DragRotationIntoEventListener.png)

Select a function to perform when the `Value Changed` event is emitted. For this example, select the `TransformEulerRotationMutator -> DoSetProperty` function (be sure to select `Dynamic Vector3 - DoSetProperty` for this example).

![Set Transformed Function](assets/images/SetTransformedFunction.png)

### Step 15

Add a `Input.CombinedActions.AxesToAngle` prefab to the Unity project hierarchy by selecting `GameObject -> Tilia -> Prefabs -> Input -> CombinedActions -> Input.CombinedActions.AxesToAngle` from the Unity main top menu.

### Step 16

On the `Input.CombinedActions.AxesToAngle` GameObject, Drag and drop the `Input.CombinedActions.BooleanTo1DAxisAction Vertical` GameObject into the `Vertical Axis` property on the `Axis To Angle Action` component.

![Drag And Drop Axes To Angle Into Horizontal Axis](assets/images/DragAndDropAxesToAngleIntoHorizontalAxis.png)

Drag and drop the `Input.CombinedActions.BooleanTo1DAxisAction Vertical` GameObject into the `Vertical Axis` property on the `Axis To Angle Action` component.

![Drag And Drop Axes To Angle Into Vertical Axis](assets/images/DragAndDropAxesToAngleIntoVerticalAxis.png)

### Step 17

Select the `Input.CombinedActions.AxesToAngle` GameObject from the Unity Hierarchy window and click the `+` symbol in the bottom right corner of the `Value Changed` event parameter on the `Axes To Angle Action` component.

Drag and drop the `Rotation` GameObject into the event listener box that appears on the `Value Changed` event parameter on the `Axes To Angle Action` component that displays `None (Object)`.

![Create Axes To Angle Event](assets/images/CreateAxesToAngleEvent.png)

Select a function to perform when the `Value Changed` event is emitted. For this example, select the `Float To Vector3 -> CurrentY` function (be sure to select `Dynamic Vector3 - CurrentY` for this example).

![Set Axes Angle Function](assets/images/SetAxesAngleFunction.png)

### Step 18

Select the `Input.CombinedActions.AxesToAngle` GameObject from the Unity Hierarchy window and click the `+` symbol in the bottom right corner of the `Value Changed` event parameter on the `Axes To Angle Action` component to add a second `Value Changed` event.

Drag and drop the `Rotation` GameObject into the event listener box that appears on the `Value Changed` event parameter on the `Axes To Angle Action` component that displays `None (Object)`.

![Create Second Axes To Angle Event](assets/images/CreateSecondAxesToAngleEvent.png)

Select a function to perform when the `Value Changed` event is emitted. For this example, select the `Float To Vector3 -> DoTransform()` function (be sure to select `Static Parameters - DoTransform()` for this example).

![Set Second Axes Angle Function](assets/images/SetSecondAxesAngleFunction.png)

### Done

Play the Unity scene, you will notice that by pressing the keys you can rotate the GameObject to change the direction it is facing.

![Done](assets/images/Done.png)

[Install the Tilia.Input.UnityInputManager.Unity]: https://github.com/ExtendRealityLtd/Tilia.Input.UnityInputManager/tree/master/Documentation/HowToGuides/Installation/README.md
[Install the Tilia.Input.CombinedActions.Unity]: ../Installation/README.md
[Unity]: https://unity3d.com/

gha_language: C#


text:
# Leptogium sessile Vain. SPECIES

#### Status
ACCEPTED

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

#### Published in
Ann. Acad. Sci. fenn. , Ser. A 6(7): 108 (1915)

#### Original name
Leptogium sessile Vain.

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
# DUGONG DEMO

To test the operation of Dugong and demonstrate the ease of use and the possibility of using the service in different operating systems and platforms we provide some installation templates on dply.co's servers.

**dply.co** allows the creation of an absolutely free server for two hours, and can be used for a longer time for payment. If you choose not to buy more time for the server, it is deleted automatically after 2 hours without any charge.

dply.co servers are hosted in the DigitalOcean cloud and have the following specifications:

- 1 CPU
- 512MB RAM
- 20GB Disk

We currently offer the following operating systems: CentOS 6, CentOS 7, Debian 7, Debian 8, Fedora 24, Fedora 25, Ubuntu 14.04, Ubuntu 16.04.

For more information on how to use this service and how to create and connect to your newly created server, go to: https://dply.co/help/faq

-------------------------------------------------------------------------------------------------------------------------------------------------

## DugongGUI

DugongGUI demo running on Dply servers. To test, just choose one of the versions below and click on the corresponding Dply button.

![Dply](https://raw.githubusercontent.com/DugongBioinformatics/Dply/master/.misc/Screenshot%20from%202017-08-06%2019-22-56.png)

![Dply](https://raw.githubusercontent.com/DugongBioinformatics/Dply/master/.misc/Screenshot%20from%202017-08-06%2019-22-44.png)

![Dply](https://raw.githubusercontent.com/DugongBioinformatics/Dply/master/.misc/Screenshot%20from%202017-08-06%2019-23-38.png)

- Ubuntu 16.04

[![Dply](https://dply.co/b.svg)](https://dply.co/b/mekdDIAk)

- Ubuntu 17.04

[![Dply](https://dply.co/b.svg)](https://dply.co/b/vaNLtfYU)

- CentOS 7

[![Dply](https://dply.co/b.svg)](https://dply.co/b/vVNyVlDA)

-------------------------------------------------------------------------------------------------------------------------------------------------

## DugongCMD:

DugongCMD demo running on Dply servers. To test, just choose one of the versions below and click on the corresponding Dply button.

![Dply](https://raw.githubusercontent.com/DugongBioinformatics/Dply/master/.misc/Screenshot%20from%202017-08-06%2017-41-55.png)

![Dply](https://raw.githubusercontent.com/DugongBioinformatics/Dply/master/.misc/Screenshot%20from%202017-08-06%2017-41-41.png)

![Dply](https://raw.githubusercontent.com/DugongBioinformatics/Dply/master/.misc/Screenshot%20from%202017-08-06%2018-02-39.png)

### Create your demo:

- Ubuntu 16.04

[![Dply](https://dply.co/b.svg)](https://dply.co/b/UUwUvOO8)

- Ubuntu 17.04

[![Dply](https://dply.co/b.svg)](https://dply.co/b/v7OzjWr5)

- CentOS 7

[![Dply](https://dply.co/b.svg)](https://dply.co/b/GyHGaXtx)

-------------------------------------------------------------------------------------------------------------------------------------------------

## Dugong CirComPara

- CirComPara

[![Dply](https://dply.co/b.svg)](https://dply.co/b/cQg4BQBi)

-------------------------------------------------------------------------------------------------------------------------------------------------

# Comments:

- The process of installing the docker service and Dugong deploy can take up to 5 minutes. I recommend that you wait for the installation process and use the command below to check if Dugong is already available:

$ docker ps

repository: DugongBioinformatics/Dply

repo_name: DugongBioinformatics/Dply


text:
# Tensor Canvas 🎨
[![PyPI version](https://badge.fury.io/py/tensor-canvas.svg)](https://badge.fury.io/py/tensor-canvas)

Tensor Canvas provides a standard API for 2D rendering directly onto tensors with pytorch, tensorflow, jax, and numpy.
SDF representations are used to implement rendering in these gpu-accelerated frameworks, which is inefficient compared to normal gpu rasterization but much more predictable than matplotlib. Integration with ML frameworks also means that it is fully-differentiable. Cross-framework support is possible thanks to the [eagerpy](https://github.com/jonasrauber/eagerpy) library.

Currently only cirlces and lines are supported, but it is straightforward to port [any 2D SDF](https://www.iquilezles.org/www/articles/distfunctions2d/distfunctions2d.htm).

### Installation

```bash
pip install tensor-canvas
```

### Example
```python
import tensorcanvas as tc
import torch
import tensorflow as tf
import jax.numpy as jnp
import numpy as np

# define 3 cirlces with different positions, radii, and colors
x1, y1, r1, c1 = 34.8,  5.3, 2.0, [0.3, 0.2, 1.0]
x2, y2, r2, c2 = 14.8, 15.3, 5.0, [0.1, 0.9, 0.8]
x3, y3, r3, c3 = 30.8, 20.3, 3.0, [0.0, 0.9, 0.0]

# canvas dimensions
height, width, channels = 32, 64, 3

# draw 3 colored circles on a pytorch image tensor
pt_canvas = torch.zeros(channels, height, width)
pt_canvas = tc.draw_circle(x1, y1, r1, torch.tensor(c1), pt_canvas)
pt_canvas = tc.draw_circle(x2, y2, r2, torch.tensor(c2), pt_canvas)
pt_canvas = tc.draw_circle(x3, y3, r3, torch.tensor(c3), pt_canvas)

# draw 3 colored cirlces on a tensorflow image tensor
tf_canvas = tf.zeros([height, width, channels])
tf_canvas = tc.draw_circle(x1, y1, r1, tf.convert_to_tensor(c1), tf_canvas)
tf_canvas = tc.draw_circle(x2, y2, r2, tf.convert_to_tensor(c2), tf_canvas)
tf_canvas = tc.draw_circle(x3, y3, r3, tf.convert_to_tensor(c3), tf_canvas)

# draw 3 colored cirlces on a jax image tensor
jx_canvas = jnp.zeros([height, width, channels])
jx_canvas = tc.draw_circle(x1, y1, r1, jnp.array(c1), jx_canvas)
jx_canvas = tc.draw_circle(x2, y2, r2, jnp.array(c2), jx_canvas)
jx_canvas = tc.draw_circle(x3, y3, r3, jnp.array(c3), jx_canvas)

# draw 3 colored cirlces on a numpy image tensor
np_canvas = np.zeros([height, width, channels])
np_canvas = tc.draw_circle(x1, y1, r1, np.array(c1), np_canvas)
np_canvas = tc.draw_circle(x2, y2, r2, np.array(c2), np_canvas)
np_canvas = tc.draw_circle(x3, y3, r3, np.array(c3), np_canvas)

# check results are indentical
assert(np.allclose(np_canvas, pt_canvas.permute(1,2,0), atol=1e-6))
assert(np.allclose(np_canvas, tf_canvas, atol=1e-6))
assert(np.allclose(np_canvas, jx_canvas, atol=1e-6))

```

### Notebook Example

[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/PWhiddy/TensorCanvasDemo/blob/master/TensorCanvasDemo.ipynb)

<img src="https://i.imgur.com/sspmxHa.png" width="653" height="763">

repository: PWhiddy/tensor-canvas

repo_name: PWhiddy/tensor-canvas


text:
#thirty years old

"30 years old" (See: [[:en:ta:vol2:translate:translate_numbers]])

#when he stood before Pharaoh

Here "stood before" stands for Joseph starting to serve Pharaoh. AT: "when he started to serve Pharaoh" (See: [[:en:ta:vol2:translate:figs_metonymy]])

#went throughout all the land of Egypt

Joseph is inspecting the country as he prepares to carry out his plans.

#In the seven bountiful years

"During the seven good years"

#the land produced abundantly

"the land produced big harvests"


text:
## `npm i ultra`

Add pushstate navigation to your component-based web app. Integrate seamlessly with React, Preact, and Vue.

| download | dependencies |
| :----: | :----: |
| `4.6 kb` | none |

### Benefits
- Embrace component paradigm, stay framework agnostic
  - Use conventions to map url string to component (sub)trees
  - Independent of rendering or view layer
    - Routing should be immune to complexity introduced by framework-level abstractions (context in React for e.g.)
- Co-locate routes to support scalability
  - Routes are data. Similar types of information are best understood if they exist in the same space.
  - On the other end, as relationships between components get more complex, it is best to leave route matching logic out of the mix.
- Extensible
  - Composable API provides clear separation between route configuration and runtime to avail maximum reuse and target different environments
- Compact
  - Ideal for mobile/progressive web apps
    - No runtime dependencies
    - `4.6 kb > ultra (> preact)`
    - Code splitting friendly

### Trade-offs
  - For modern browsers with pushstate support
  - Does not render component or fetch data
  - Relies on use of path keys (strings) to derive result
    - More complex update process involves replacing path keys throughout the app
    - Path keys (non-minified) may contribute to bloated bundles
      - Concern for apps with _multiple_ deeply nested routes, e.g. Amazon
  - For the Developer: Overcome the notion of changing your routing code again this season, and actually following through. No pun intended.

### Resources

- [Quick start](https://github.com/gt3/ultra-router/wiki/Quick-start) (build navigation for a news website tutorial)
- React bindings: [react-ultra](https://github.com/gt3/react-ultra)
- Code examples in `/examples` directory
  - Vehicle shop: [jsfiddle](http://jsfiddle.net/cheekyiscool/1n7v87aq/embedded/js,html,result/dark/)
  - Tap (intercept routing): [jsfiddle](http://jsfiddle.net/cheekyiscool/y9f8j44u/embedded/js,html,result/dark/)
  - Loading modules and routes dynamically

### To-dos
- Create automated cross-browser test suite
- Add Preact and Vue.js examples
- Implement Node.js container for [ultra-router](https://www.npmjs.com/package/ultra-router)

### License

MIT

---

> Handle a route or two without breaking a sweat. :crossed_swords: `ULTRA`


text:
# Doctor Finder

#### Web app using JavaScript, Node.js and BetterDoctor API, May 26, 2017

### By Bryan Lin

## Description

Doctor Finder is a web application that utilizes the BetterDoctor API to search for doctors in the Seattle area matching the user query. Users can search for doctors based on either doctor name and/or medical issue requiring attention. The application is built with JavaScript and Node.js, and uses data from the BetterDoctor API.

## Setup/Installation Requirements

* Clone the repository (https://github.com/bryanlin39/doctor-finder.git)
* Visit the BetterDoctor API site at https://developer.betterdoctor.com/
  * Click "Get a free API key" and follow the instructions to acquire an API key
* Create an .env file at the top level of the directory
  * In it, type "exports.apiKey = " + your API Key inside quotes
* Run "npm install" in the terminal to install all Node packages
* Run "bower install" in the terminal to install all Bower packages for managing the front-end
* Run "gulp build --production" in the terminal to optimize the workflow into a production build
* Run "gulp serve" in the terminal to launch the server and run the app

## Known Bugs

None

## Support and Contact Information

For any comments or concerns, please email Bryan at<EMAIL_ADDRESS>
## Technologies Used

* JavaScript
* JQuery
* Node.js
  * Node package manager (npm)
  * Bower package manager
* BetterDoctor API
* HTML
* CSS
* Bootstrap

### License

MIT License

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Copyright (c) 2017 Bryan Lin


text:
---
title: What is Localization
page_title: What is Localization
description: What is Localization
slug: radcontrols-windows8-xaml-whatislocalization
tags: what,is,localization
published: True
position: 0
---

# What is Localization

> Localization is the translation of application resources into localized versions for the specific cultures or into customized resources.

The culture of your application is set to your operating system's culture by default. However, you can change it easily from your application:

1. Open Package.appxmanifest from the Solution Explorer.
1. Type the desired language code in the Default Language textbox.
![Default Language](images/Localization/DefaultLanguage.png)

## Custom Localization

**{{ site.productName }}** allows you to do custom Localization through the **LocalizationManager** class using your own **resource files(.resw)** or **StringLoader** to define the changes you want to make - see the [How to Localize]({%slug radcontrols-windows8-xaml-howtolocalize%}) article.

You can change the localization in the current assembly using:

* **StringLoader** -  Uses your own implemented method for localization

* **UserResourceMap** - Uses your own created resource file. This file contains a table with keys values where you can set your own values.

You can change the localization for all controls using:

* **GlobalResourceMap** - Uses custom resource file.

repository: telerik/uwp-docs

gha_language: HTML

repo_name: telerik/uwp-docs


text:
# Development Journal

## Monday March 12

I started the project today. Spent some time over the weekend getting a grasp of TypeScript in order to use it for the project.
Most of my time today was configuring and setting up TypeScript, Babel and Webpack.

Initially I wanted to the new Webpack v4, but after some time tinkering, I decided to downgrade to v3 as it doesn't seem like the typescript loaders for v4 are working properly.

Currently have Webpack setup with Hot-Module loading for React. Also used the `HtmlWebpackPlugin` and the `html-webpack-template` to auto-generate an `index.html` file instead of creating one myself.
The current set up should be fine, but if I have extra time I may tinker with it some more and create a production version.

## Tuesday March 13

Didn't have much time to work on the project today. I spent my time setting up React Router and Redux.
And built out the skeleton of the application.

## Wednesday March 14

Today I spent a several hours working on the project today. Starting to get the hang of TypeScript.
I'm really enjoying the development experience. Since I'm still learning a lot it's slowed me down somewhat, fixing compiler errors, but it is catching a lot of errors that I would have missed in regular JS.
Plus I'm really loving using `enums` with `redux` instead of string constants.

I refactored the Root component and added a `componentDidCatch` method to catch anything that may happen outside of the Redux state.

Speaking of state, I really dug into building out the state.
Created a `typeKeys` file with an `enum` for holding all the action constants.
The `actionTypes` file contains interfaces for all the action types.
Action creators live in `actionCreators` along with their type signatures.
The `initial` file holds the initial state for the reducers and state interfaces.
The `reducers` file is self-explanatory and the `index` file configures the middleware and sets up the redux store.

I could merge some of the files on a short project like this but I like tidy files and it's good habit to separate concerns, especially if this were the start of larger project where there would be dozens of actions.

Also created a service using `axios` to send HTTP requests. Tomorrow I'll write some `epics` for turning the requests into `Observables` and connect it to the `redux` store. As well as building out the UI.

The only really frustrating issue I encountered today is a compiler error on the redux connector for the `Ping` component.
The component is just for testing out `redux-observable` which I think I have set up properly.
But the compiler is complaining that:

`
Types of parameters 'state' and 'state' are incompatible. Type '{}' is not assignable to type 'IAppState'. Property 'routing' is missing in type '{}'.
`

I think I may be too specific with the types, but I'm not positive.
Going to sleep on it and figure it out tomorrow.

Lastly, if you're reading this you may be wondering why I haven't started working on the Search components yet.
Typically I'd start out building the key features first.
However completed a technical challenge a couple of weeks ago where I was asked to build a similar app with React, but for searching for SubReddits.

I like learning new things, so I decided to make this challenge more challenging by building it in TypeScript and using Observables.

## Thursday March 15

I'm too tired to write this now. Gonna update it tomorrow.

## Monday March 19

Forgot about this over the weekend, whoops!

repository: zacaytion/giphy-search

repo_name: zacaytion/giphy-search


text:
# React Native Measure Text
# Both platform support Now!

Measure text height without laying it out.

## Installation

### Automatic installation

`$ yarn add react-native-measure-text`

`$ react-native link`

### Manual installation

#### iOS

1. In XCode, in the project navigator, right click `Libraries` ➜ `Add Files to [your project's name]`
2. Go to `node_modules` ➜ `react-native-measure-text` and add `RNMeasureText.xcodeproj`
3. In XCode, in the project navigator, select your project. Add `libRNMeasureText.a` to your project's `Build Phases` ➜ `Link Binary With Libraries`
4. Run your project (`Cmd+R`)<

#### Android

1. Open up `android/app/src/main/java/[...]/MainActivity.java`
  - Add `import io.github.airamrguez.RNMeasureTextPackage;` to the imports at the top of the file
  - Add `new RNMeasureTextPackage()` to the list returned by the `getPackages()` method
2. Append the following lines to `android/settings.gradle`:
  	```
  	include ':react-native-measure-text'
  	project(':react-native-measure-text').projectDir = new File(rootProject.projectDir, 	'../node_modules/react-native-measure-text/android')
  	```
3. Insert the following lines inside the dependencies block in `android/app/build.gradle`:
  	```
      compile project(':react-native-measure-text')
  	```

## Usage
```javascript
import MeasureText from 'react-native-measure-text';

const texts = [
  'This is an example',
  'This is the second line'
];
const width = 100;
const fontSize = 15;

class Test extends Component {
  state = {
    heights: [],
  }
  async componentDidMount() {
    const heights = await MeasureText.measure({(
      texts, /* texts to measure */
      width, /* container width */
      fontSize,
      fontFamily:'Montserrat-Regular',
    );
    this.setState({ heights });
  }
  render() {
    const { heights } = this.state;
    return (
      <View>
        {texts.map((text, i) => (
          <Text
            key={`text-${i}`}
            style={{
              width,
              fontSize,
              height: heights[i],
            }}
          >
            {text}
          </Text>
        ));
      );}
    </View>
  }
}
```

gha_language: Objective-C


text:
# Bar Chart Race

Make animated bar and line chart races in Python with matplotlib or plotly.

Original Repo (without icons) : [https://github.com/dexplo/bar_chart_race](https://github.com/dexplo/bar_chart_race)

Andres Berejnoi's Repo (with
icons) : [https://github.com/andresberejnoi/bar_chart_race](https://github.com/andresberejnoi/bar_chart_race)

This project adds a new argument end_pause that adds a pause at the end of the animation.

---

## Top Computer Science Schools 2000 - 2020

![img](demo.gif)

---

## Installation

First Create a New Virtual Environment & Activate It:

```
pip install virtualenv
virtualenv venv
.\venv\Scripts\activate
```

Install `bar_chart_race` using `pip`:

```
pip install git+https://github.com/drake10k/bar_chart_race.git
```

You also need to install
FFmpeg: [https://github.com/BtbN/FFmpeg-Builds/releases/](https://github.com/BtbN/FFmpeg-Builds/releases/)

---

## Usage

Create a file and use the `bar_chart_race` library as shown below:

```python
import bar_chart_race as bcr
import pandas as pd

df = pd.read_csv("data.csv", index_col="Date")

# replace empty values with 0
df.fillna(0.0, inplace=True)

# using the bar_chart_race package
bcr.bar_chart_race(
    # must be a DataFrame where each row represents a single period of time.
    df=df,

    # name of the video file
    filename="video.mp4",

    # specify location of image folder
    img_label_folder="bar_image_labels",

    # change the Figure properties
    fig_kwargs={
        'figsize': (26, 15),
        'dpi': 120,
        'facecolor': '#F8FAFF'
    },

    # orientation of the bar: h or v
    orientation="h",

    # sort the bar for each period
    sort="desc",

    # number of bars to display in each frame
    n_bars=10,

    # to fix the maximum value of the axis
    # fixed_max=True,

    # smoothness of the animation
    steps_per_period=45,

    # time period in ms for each row
    period_length=1500,

    # custom set of colors
    colors=[
        '#6ECBCE', '#FF2243', '#FFC33D', '#CE9673', '#FFA0FF', '#6501E5', '#F79522', '#699AF8', '#34718E', '#00DBCD',
        '#00A3FF', '#F8A737', '#56BD5B', '#D40CE5', '#6936F9', '#FF317B', '#0000F3', '#FFA0A0', '#31FF83', '#0556F3'
    ],

    # title and its styles
    title={'label': 'Programming Language Popularity 1990 - 2020',
           'size': 52,
           'weight': 'bold',
           'pad': 40
           },

    # adjust the position and style of the period label
    period_label={'x': .95, 'y': .15,
                  'ha': 'right',
                  'va': 'center',
                  'size': 72,
                  'weight': 'semibold'
                  },

    # style the bar label text
    bar_label_font={'size': 27},

    # style the labels in x and y axis
    tick_label_font={'size': 27},

    # adjust the style of bar
    # alpha is opacity of bar
    # ls - width of edge
    bar_kwargs={'alpha': .99, 'lw': 0},

    # adjust the bar label format
    bar_texttemplate='{x:.2f}',

    # adjust the period label format
    period_template='{x:.0f}',

    # add a pause at the end of the animation
    end_pause = 125 #about 5 seconds
)
```


text:
# Aplanochytrium thaisii (B.A. Cox & Mackin) C.A. Leander & D. Porter SPECIES

#### Status
SYNONYM

#### According to
Index Fungorum

#### Published in
null

#### Original name
Labyrinthula thais B.A. Cox & Mackin, 1974

### Remarks
null

path: /life/Chromista/Labyrinthista/Labyrinthulea/Thraustochytriales/Thraustochytriaceae/Aplanochytrium/Aplanochytrium thais/ Syn. Aplanochytrium thaisii/README.md


text:
# UE4 Plugin: Noise Blueprint Library

This UE4 plugin provides utility Blueprint Functions to generate noises.

## Supported Environment

This plugin is tested on the below environment.

* UE4 Version: 4.22
* OS: Windows/Mac

## Installation

#### 1. Download source codes

Download whole project's source codes from [GitHub](https://github.com/nutti/UE4-Noise-BlueprintLibrary/archive/master.zip) and unzip them.

#### 2. Copy the plugin source codes

Copy the plugin source codes (`NoiseBlueprintLibrary` directory) into the plugin directory (`Plugin` directory) on your UE4 project.

#### 3. Generate a project file for each IDE

Generate a project file for Visual Studio (Windows) or XCode (Mac).

#### 4. Build

Build whole source codes including plugin source codes.

#### 5. Launch UE4 editor and enable plugin

Launch .uproject file and enable plugin via *Settings* > *Plugins* > *Project* > *Blueprints* > *Noise Blueprint Library*

.
## Features / Tutorials

### Perlin Noise

* `Perlin Nose 1D/2D/3D` generates perlin noise
   * Input
      * X, Y, Z: Position
      * Frequency: Frequency
      * Amplitude: Scale factor of generated noise
   * Output
      * Out: Generated Noise [0.0, 1.0 * Amplitude]
* `Octave Perlin Noise 1D/2D/3D` generates perlin noise accumulated from different octaves
   * Each octave generates a noise whose frequency is *2^(octave-1)* and amplitude is *persistence^(octave-1)*
   * Input
      * X, Y, Z: Position
      * Octave: Number of octaves
      * Persistence: Base of amplitude
   * Output
      * Out: Generated Noise [0.0, 1.0 * Amplitude * Octave]
* `Accumulated Perlin Noise 1D/2D/3D` generates perlin noise accumulated from different frequencies and amplitudes
   * Input
      * Frequencies: Frequencies
      * Amplitudes: Scale factors of generated noise
      * X, Y, Z: Position
   * Output
      * Out: Generated Noise [0.0, 1.0 * Sum(Amplitudes)]

![](docs/images/perlin_noise.png)

#### Application of Perlin Noise

* Generate Terrain

![](docs/images/perlin_noise_example_generate_terrain.png)

## Change Log

See [CHANGELOG.md](CHANGELOG.md)

## Project Authors

### Owner

[**@nutti**](https://github.com/nutti)

Indie Game/Application Developer.
Especially, I spend most time to improve Blender and Unreal Game Engine via providing the extensions.

Support via [GitHub Sponsors](https://github.com/sponsors/nutti)

* CONTACTS: [Twitter](https://twitter.com/nutti__)
* WEBSITE: [Japanese Only](https://colorful-pico.net/)


text:
+++
title = "Groups of spokes"
chapter = false
weight = 30

+++

## What are we going to do?

If you have enabled AWS Organizations support you may want to bootstrap all spokes within an organizational unit.

Following these steps will allow you to bootstrap all AWS Accounts that exist within the same organizational unit.

### Using the CodeBuild Project

In your AWS Account you can find an AWS CodeBuild project named: `servicecatalog-puppet-bootstrap-an-ou`

- Click _Start Build_

- Before you select _Start Build_ again, expand the _Environment variables override_ section.

- Set *OU_OR_PATH* to the OU path or AWS Organizational Unit ID that contains all of the spokes you want to bootstrap

- Set *IAM_ROLE_NAME* to the name of the IAM Role that is assumable in the spoke accounts - this must be the same name in all accounts

- Set *IAM_ROLE_ARNS* to the ARNs you want to assume before assuming before the *IAM_ROLE_NAME*.  This is should you need to assume a role with cross account permissions.

- Click _Start Build_ again

### Using the CLI

The following steps should be executed using the Service Catalog Puppet CLI which is an application built using Python 3.7.

If you have not already installed the framework you can do so by following these steps:

#### Create an isolated Python environment

It is good practice to install Python libraries in isolated environments.

You can create the a virtual environment using the following command:

{{< highlight bash >}}
virtualenv --python=python3.7 venv
source venv/bin/activate
{{< / highlight >}}

#### Install the package locally

Once you have decided where to install the library you can install the package:

{{< highlight bash >}}
pip install aws-service-catalog-puppet
{{< / highlight >}}

This will install the library and all of the dependencies.

#### Bootstrapping spokes in OU

You should export the credentials for the account that allows you to list accounts in the org and assume an IAM Role in each
of the spokes.

Then you can run the following command:

_Without a Permission Boundary_
{{< highlight bash >}}
servicecatalog-puppet bootstrap-spokes-in-ou /dev DevOpsAdminRole
{{< / highlight >}}

In this example /dev is the ou path and DevOpsAdminRole is the name of the assumable role in each spoke account.

_With a Permission Boundary_
{{< highlight bash >}}
servicecatalog-puppet bootstrap-spokes-in-ou /dev DevOpsAdminRole --permission-boundary arn:aws:iam::aws:policy/AdministratorAccess
{{< / highlight >}}

If your current role does not allow you to list accounts in the AWS Organization or allow you to *assume-role* across AWS accounts you can
specify an ARN of an IAM role that does. When you do so the framework will assume that IAM Role first and then perform the
bootstrapping.

{{< highlight bash >}}
servicecatalog-puppet bootstrap-spokes-in-ou /dev DevOpsAdminRole arn:aws:iam::0123456789010:role/OrgRoleThatAllowsListAndAssumeRole
{{< / highlight >}}

You can use the following AWS CloudFormation template to provision the needed role:

{{< highlight yaml >}}
# Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0

AWSTemplateFormatVersion: '2010-09-09'
Description: IAM Role needed to use AWS Organizations to assume role into member AWS Accounts.

Parameters:
  ServiceCatalogFactoryAccountId:
    Description: The account you will be installing AWS Service Catalog Factory into
    Type: String

  OrganizationAccountAccessRole:
    Description: Name of the IAM role used to access cross accounts for AWS Orgs usage
    Default: OrganizationAccountAccessRole
    Type: String

Resources:
  RoleForBootstrappingSpokes:
    Type: AWS::IAM::Role
    Description: |
      IAM Role needed by the account vending machine so it can create and move accounts
    Properties:
      Path: /servicecatalog-puppet/
      Policies:
        - PolicyName: Organizations
          PolicyDocument:
            Version: 2012-10-17
            Statement:
              - Effect: Allow
                Action:
                  - sts:AssumeRole
                Resource: !Sub "arn:aws:iam::*:role/${OrganizationAccountAccessRole}"
      AssumeRolePolicyDocument:
        Version: "2012-10-17"
        Statement:
          - Effect: "Allow"
            Principal:
              AWS: !Sub "arn:aws:iam::${ServiceCatalogFactoryAccountId}:root"
            Action:
              - "sts:AssumeRole"

Outputs:
  RoleForBootstrappingSpokesArn:
    Description: The ARN for your Assumable role in root account
    Value: !GetAtt RoleForBootstrappingSpokes.Arn
{{< / highlight >}}


text:
# Carnagie Libraries

* https://en.wikipedia.org/wiki/List_of_Carnegie_libraries_in_California
* https://sfpl.org/pdf/libraries/main/about/carnegie_branch_libraries.pdf

## Walter Bliss

* https://en.wikipedia.org/wiki/Walter_Danforth_Bliss

## Ernest Coxhead

* https://en.wikipedia.org/wiki/Ernest_Coxhead

## G. Albert Lansburgh

* https://en.wikipedia.org/wiki/G._Albert_Lansburgh
* https://pcad.lib.washington.edu/person/123/

## John W. Reid Jr

* https://en.wikipedia.org/wiki/John_W._Reid_Jr.
* https://pcad.lib.washington.edu/person/1551/

## Richmond, 351 Ninth Avenue, built 1914
The library was designed by Bliss & Faville in the Classical Revival style and composed of sandstone and reinforced concrete. First Carnagie library. Bliss & Faville also designed the St Francis Hotel and the Metropolitan Club.

* https://pcad.lib.washington.edu/building/19247/
* https://noehill.com/sf/landmarks/sf247.asp
* https://sfpl.org/locations/richmond/library-history

## Mission, 300 Bartlett Street, 3359 24th St, built 1916
First San Francisco branch library in 1888. G. Alfred Lansburgh designed the current building in the Italian Renaissance style.

* https://pcad.lib.washington.edu/building/19251/
* http://www.carnegie-libraries.org/california/sf-mission.html
* https://noehill.com/sf/landmarks/sf234.asp
* https://sfpl.org/locations/mission/mission-library-history

## Noe Valley, 451 Jersey Street, built 1916
The library was designed by John Reid Jr. The tall rectangular building under a low gable tiled roof, is faced with brick laid in a tapestry pattern. Five large windows framed together and slightly recessed, are separated by slim columns resting on one long sill. John Reid Jr. also designed several schools in San Francisco.

* https://pcad.lib.washington.edu/building/12822/
* https://www.carnegie-libraries.org/california/sf-noevalley.html
* https://noehill.com/sf/landmarks/sf259.asp
* https://sfpl.org/locations/noe-valley/noe-valley-library-history

## Golden Gate, 1801 Green Street, built 1918
Architect Ernest Coxhead designed the library in the Classical Revival style which resembles a Roman basilica with its long narrow rectangle and curved apse visible on three sides.

* https://pcad.lib.washington.edu/building/24300/
* https://www.carnegie-libraries.org/california/sf-goldengate.html
* https://noehill.com/sf/landmarks/poi_carnegie_library_golden_gate_branch.asp
* https://sfpl.org/locations/golden-gate-valley/golden-gate-valley-library-history

## Sunset, 1305 18th Avenue, built 1918
G. Albert Lansburgh designed the building in the Classical Revival style. The central entrance is recessed within a loggia formed by three tall round arches supported by two segmented Corinthian columns and two pilasters. Built of with a concrete frame and reinforced masonry. Names of authors, many western, are inscribed under the sills of recessed arched windows.

* https://www.carnegie-libraries.org/california/sf-sunset.html
* https://noehill.com/sf/landmarks/sf239.asp
* https://sfpl.org/locations/sunset/sunset-library-history

## Chinatown, 1135 Powell Street, built 1921
This branch library was designed by G. Alfred Lansburgh in the Italian Renaissance style.

* https://www.carnegie-libraries.org/california/sf-chinatown.html
* https://noehill.com/sf/landmarks/sf235.asp
* https://sfpl.org/locations/chinatown/chinatown-library-history

## Presidio, 3150 Sacramento Street, built 1921
G. Alfred Lansburgh designed the library in the Italian Renaissance style.   Landscaping was directed by John McLaren. Carnegie supplied $83,228.  Largest. The library also houses the city's only Library for the Blind.

* http://www.carnegie-libraries.org/california/sf-presidio.html
* https://noehill.com/sf/landmarks/sf240.asp
* https://sfpl.org/locations/presidio/presidio-library-history

repository: theo-armour/pages

repo_name: theo-armour/pages


text:
# TSNode
Learning Typescript Restfull APIs with express, mongoose and Cors
# Testing
    - Use postman to import TSNode.postman_collection.json
    - Open the project folder on your terminal of choice and type
        $ yarn dev

repository: jjackbauer/TSNode

repo_name: jjackbauer/TSNode


text:
# Activerecord Plurals
A simple rails plugin for batch-retrieving specific fields of activerecord models.

## Installation
As rails plugin:
`rails plugin install git://github.com/gurdotan/activerecord_plurals.git`

As a gem:
Add `gem "activerecord_plurals"` to your Gemfile and run `bundle install`.

## Usage
For example, assume we have a table of animals, assocsiated to the `Animal` ActiveRecord model.  We can do the following:

    >> Animal.names
    => ["Horse", "Cat", "Dog", "Chimpanzee", "Snake"]

    >> Animal.ids
    => [1, 2, 3, 4, 5]

    >> Animal.where(:type => "domestic").names
    => ["Cat", "Dog"]

So in fact this plugin supplies you with plural methods for all activerecord fields.  That includes all of the model's fields, along with `ids`, `created_ats` and `updated_ats`.

### Known Issues
 * If you have an activerecord model with a field who's plural form collides with an already exsiting method (say 'entry' collides with `Object#entries`), you won't be able to invoke a plural method, the original method will be called.

These issues will be fixed in the next release.

### Testing Notes
 * To run the tests:
    cd <RAILS_ROOT>/vendor/plugins/activerecord_plurals
    rake
 * The tests are written in rspec and make use of a private SQLite3 DB file.  This is why you will need to run `bundle install` in order to run the tests.  Bundler will install the sqlite3-ruby gem which is a dependency of the tests.
 * Tested only on Rails 3.

Knock yourselves out!

Copyright (c) 2011 Gur Dotan, released under the MIT license.


text:
# FIT-to-GPX

Simple Perl script which, in conjunction with a Java script from the ANT consortium's FIT SDK,
converts a FIT file to a GPX file appropriate for upload to Strava.

Requires the free FIT SDK from https://www.thisisant.com/developer/resources/downloads/
As of May 2017, the SDK works with FIT versions 1 and 2.

See configuration and usage instructions at the top of fit2gpx

repository: omatainstruments/FIT-to-GPX

repo_name: omatainstruments/FIT-to-GPX


text:
### /packages/client/src/ui

This folder contains reusable components, which could be used as a UI kit (after some customization) in another project.

### Available Blueprint templates in this folder

- `component`: creates a new React component, template variables:
  - `[value]`: name of the component

repository: galacticcouncil/polkalert

repo_name: galacticcouncil/polkalert


text:
# Discord Manager

[![packagist](https://badgen.net/packagist/v/revolution/discord-manager)](https://packagist.org/packages/revolution/discord-manager)
[![Maintainability](https://api.codeclimate.com/v1/badges/27e52e9ba3df10623fae/maintainability)](https://codeclimate.com/github/kawax/discord-manager/maintainability)
[![Test Coverage](https://api.codeclimate.com/v1/badges/27e52e9ba3df10623fae/test_coverage)](https://codeclimate.com/github/kawax/discord-manager/test_coverage)

- https://github.com/kawax/discord-interactions

> **Note** Since v5, only Interactions command is provided. Interactions command is webhook-based, it is easy to use in Laravel. [v4](https://github.com/kawax/discord-manager/tree/4.x) still support Gateway API.

## Requirements
- PHP >= 8.1
- Laravel >= 9.0

## Installation

```shell
composer require revolution/discord-manager
```

### .env
```
DISCORD_BOT_TOKEN=

# APPLICATION ID
DISCORD_BOT=

# PUBLIC KEY
DISCORD_PUBLIC_KEY=

DISCORD_GUILD=
```

### Uninstall
```shell
composer remove revolution/discord-manager
```

- Delete `config/discord_interactions.php`
- Delete `app/Discord/` and other files.
- Delete `DISCORD_*` in `.env`

## Interactions
### Publish config file
```shell
php artisan vendor:publish --tag=discord-interactions-config
```

### Edit config/discord_interactions.php

### Set `INTERACTIONS ENDPOINT URL` in Discord's developer portal.
```
https://example/discord/webhook
```

### Create a command to respond
```shell
php artisan discord:make:interaction HelloCommand
```

### Register commands to Discord server
```shell
php artisan discord:interactions:register
```

### Create Event listener
```shell
php artisan make:listener InteractionsListener
```

```php
use Revolution\DiscordManager\Events\InteractionsWebhook;
use Revolution\DiscordManager\Facades\DiscordManager;

//

    /**
     * Handle the event.
     *
     * @param  InteractionsWebhook  $event
     * @return void
     */
    public function handle(InteractionsWebhook $event)
    {
        DiscordManager::interaction($event->request);
    }
```

EventServiceProvider.php
```php
use App\Listeners\InteractionsListener;
use Revolution\DiscordManager\Events\InteractionsWebhook;

//

    protected $listen = [
        Registered::class => [
            SendEmailVerificationNotification::class,
        ],
        InteractionsWebhook::class => [
            InteractionsListener::class,
        ],
    ];
```

## Workflow
1. POST request comes in from Discord to https://example/discord/webhook
2. [ValidateSignature](./src/Http/Middleware/ValidateSignature.php)
3. [InteractionsWebhookController](./src/Http/Controllers/InteractionsWebhookController.php)
4. [DeferredResponse](./src/Http/Response/DeferredResponse.php)
5. [DispatchInteractionsEvent](./src/Http/Middleware/DispatchInteractionsEvent.php) Terminable Middleware
6. [InteractionsWebhook](./src/Events/InteractionsWebhook.php) Event dispatch
7. InteractionsListener in your project.
8. DiscordManager invokes one of the commands in `app/Discord/`.

## LICENSE
MIT

repository: kawax/discord-manager

gha_language: PHP

repo_name: kawax/discord-manager


text:
SEGSegmentedViewController
-------------

A UIViewController subclass used to allow choosing the displayed controller via a UISegmentedControl. Sources titles from the contained controllers, or presents icons if you prefer.

###Installation
Until Xcode supports Swift in static libraries, or Cocoapods finds a way to accommodate this, you'll have to drag-n-drop the files into your project.

###Usage
Subclass SegmentedViewController (Swift)/SEGSegmentedViewControll (Obj-C), override viewDidLoad and call one of the many addController overloads to present your controllers. You must instantiate your controllers and provide them at this time (via instantiateViewControllerWithIdentifier on your storyboard, for instance).

###Future Work
- Segues could be used to map relations between the SegmentedViewController and the controllers to be presented within its segments
- Abstracting the segment control implementation is worth considering (so something other than UISegmentedControl could be used)

###License

Available for use under the MIT license: http://bryan.mit-license.org


text:
---
severity: Awareness
pillar: Operational Excellence
category: Repeatable infrastructure
resource: Front Door
online version: https://azure.github.io/PSRule.Rules.Azure/en/rules/Azure.FrontDoor.WAF.Name/
---

# Use valid Front Door WAF policy names

## SYNOPSIS

Front Door WAF policy names should meet naming requirements.

## DESCRIPTION

When naming Azure resources, resource names must meet service requirements.
The requirements for Front Door Web Application Firewall (WAF) policy names are:

- Between 1 and 128 characters long.
- Letters or numbers.
- Start with a letter.
- Unique within a resource group.

## RECOMMENDATION

Consider using names that meet Front Door WAF policy naming requirements.
Additionally consider naming resources with a standard naming convention.

## NOTES

This rule does not check if Front Door WAF policy names are unique.

## LINKS

- [Repeatable infrastructure](https://learn.microsoft.com/azure/architecture/framework/devops/automation-infrastructure)
- [Naming rules and restrictions for Azure resources](https://docs.microsoft.com/azure/azure-resource-manager/management/resource-name-rules)
- [Azure deployment reference](https://docs.microsoft.com/azure/templates/microsoft.network/frontdoorwebapplicationfirewallpolicies)
- [Tagging and resource naming](https://learn.microsoft.com/azure/architecture/framework/devops/app-design#tagging-and-resource-naming)

gha_language: PowerShell


text:
# soluble/spreadsheet

[![PHP Version](http://img.shields.io/badge/php-5.5+-ff69b4.svg)](https://packagist.org/packages/soluble/spreadsheet)
[![Build Status](https://travis-ci.org/belgattitude/soluble-spreadsheet.png?branch=master)](https://travis-ci.org/belgattitude/soluble-spreadsheet)
[![Code Coverage](https://scrutinizer-ci.com/g/belgattitude/soluble-spreadsheet/badges/coverage.png?s=aaa552f6313a3a50145f0e87b252c84677c22aa9)](https://scrutinizer-ci.com/g/belgattitude/soluble-spreadsheet)
[![Scrutinizer Quality Score](https://scrutinizer-ci.com/g/belgattitude/soluble-spreadsheet/badges/quality-score.png?s=6f3ab91f916bf642f248e82c29857f94cb50bb33)](https://scrutinizer-ci.com/g/belgattitude/soluble-spreadsheet)
[![Latest Stable Version](https://poser.pugx.org/soluble/spreadsheet/v/stable.svg)](https://packagist.org/packages/soluble/spreadsheet)
[![Total Downloads](https://poser.pugx.org/soluble/spreadsheet/downloads.png)](https://packagist.org/packages/soluble/spreadsheet)
[![License](https://poser.pugx.org/soluble/spreadsheet/license.png)](https://packagist.org/packages/soluble/spreadsheet)

## Introduction
soluble-spreadsheet provides a generic wrapper for generating excel documents in PHP.

**Warning: soluble-spreadsheet is currently a proof of concept and is limited to the libxl/php_excel extension wrapper. In the future it should be possible to exchange the underlying driver between PHPExcel, native LibXL, Spout or any future implementations without loosing compatibility. PR's and ideas are welcome.**

## Requirements

- PHP 5.5+ or 7.0+
- [libxl php extension](https://github.com/iliaal/php_excel.git)

## Documentation

 - [Manual](http://docs.soluble.io/soluble-spreadsheet/manual/) in progress and [API documentation](http://docs.soluble.io/soluble-spreadsheet/api/) available.

## Installation

Instant installation via [composer](http://getcomposer.org/).

1. Installing in your PHP project

    ```console
    $ php composer require soluble/spreadsheet:0.*
    ```
    Most modern frameworks will include Composer out of the box, but ensure the following file is included:
    ```php

    <?php
    // include the Composer autoloader
    require 'vendor/autoload.php';
    ```

2. Installing libXL / php_excel extension

    Take a look to the [install the libxl / php_excel extension document](./doc/install/install_libxl_php_excel.md).

## Examples

### Create an excel file

```php
<?php
use Soluble\Spreadsheet\Library\LibXL;

$libxl = new LibXL($valid_license);

$bookXLS  = $libxl->getExcelBook(LibXL::FILE_FORMAT_XLS);
$bookXLSX = $libxl->getExcelBook(LibXL::FILE_FORMAT_XLSX);

```

## Supported drivers (state)

| Name                                                   | Language      | License        | Support             |
|--------------------------------------------------------|---------------|----------------|---------------------|
| [libXL/php_excel](https://github.com/iliaal/php_excel) | C   (fast)    | Commercial     | Initial support     |
| [PHPExcel](https://github.com/PHPOffice/PHPExcel)     | PHP (slow)    | Opensource     | Not yet implemented |
| [Spout](https://github.com/box/spout)                  | PHP (medium)  | Opensource     | Not yet implemented |
| [POI](https://poi.apache.org/)                         | Java (fast)   | Opensource     | Not yet implemented |

## Contributing

Contribution are welcome see [contribution guide](./CONTRIBUTING.md)

## Coding standards

* [PSR 4 Autoloader](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-4-autoloader.md)
* [PSR 2 Coding Style Guide](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-2-coding-style-guide.md)
* [PSR 1 Coding Standards](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-1-basic-coding-standard.md)
* [PSR 0 Autoloading standards](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-0.md)

repository: belgattitude/soluble-spreadsheet

repo_name: belgattitude/soluble-spreadsheet


text:
# CoffeeScript support for ember-cli [![Build Status](https://travis-ci.org/kimroen/ember-cli-coffeescript.svg?branch=master)](https://travis-ci.org/kimroen/ember-cli-coffeescript)
Adds precompilation of CoffeeScript files and all the basic generation
types to the `ember generate` command, as well as linting.

### Includes
- Generating files in CoffeeScript with `ember generate`
- Preprocessing CoffeeScript-files in your app, including tests
- Linting your CoffeeScript-files.

### Install
```
ember install ember-cli-coffeescript
```

**NB**: ember-cli-coffeescript is tested using ember-cli version `2.3.0` and up. Some of it probably works on
earlier versions, but I wouldn't know.

### How to use

#### Blueprints
Run `ember help generate` to get a list of available blueprints. Use them by running `ember g <blueprint> <args>`. For instance, to generate a component:

```
ember g component my-component
```

ember-cli-coffeescript comes with pod-support for the same blueprints as ember-cli
does. Check out [the ember-cli docs for pods](https://ember-cli.com/user-guide/#using-pods)
for instructions on how to use it.

If you'd like to use ember-cli-coffeescript without the blueprints, you can add
the following to your `config/environment.js`:

```js
ENV.coffeeOptions = {
  blueprints: false
}
```

This will make it fall back to the next blueprints in line (probably the ones
from ember-cli).

#### Precompiling
This will happen automatically - no work necessary.

#### Linting
If you have a `coffeelint.json` file in the root of you project we will automatically pick up on it and start running linting on files when using the `ember build` and `ember serve` commands.
If you do not want linting to run despite having a `coffeelint.json` file, use the following configuration
in your `config/environment.js`.

```js
ENV.coffeeOptions = {
  lint: false
}
```

You can set `lint` to `true` to enable linting with the default configurations even without a custom `coffeelint.json` file.

You can find all the [available options on the website for `coffeelint`](http://www.coffeelint.org/#options).

If you want to specify a different path for your `coffeelint.json` file you can specify the path
(relative to the project directory or absolute)

```js
ENV.coffeeOptions = {
  lint: {
    configPath: "configurations/coffeelint.json"
  }
}
```

If you want to change the way we format the linting output you can specify custom error output and stats output functions:

```js
ENV.coffeeOptions = {
  lint: {
    formatter: function(filePath, lintResults) {  },
    statsFormatter: function(stats) { console.log('Files: ', stats.fileCount, "Errors: ", stats.errorCount) }
  }
}
```

**NOTE:** The lint results will show up twice when you build and run your app; once
for the app files, and then once for the test files. On rebuild, only the changed
files are linted.

##### Lintignore
To avoid linting specific files or folders, you can put a file named `.coffeelintignore`
in the root of your project containing ignore-rules, one per line. This is just like a
`.gitignore`-file, and it will follow the same rules.

### Developing
- `git clone` this repository
- `npm install`
- `bower install`
- `npm link`

Because of the nature of this project, it needs to be consumed by an ember-cli project to be properly developed.

- Add `"ember-cli-coffeescript": "*"` to your consuming project's `package.json`
- From your project root run `npm link ember-cli-coffeescript`

### Running Tests
- `ember test`
- `npm run embertest`
- `npm run nodetest`

To run all the tests:

- `npm test`

repository: kimroen/ember-cli-coffeescript

repo_name: kimroen/ember-cli-coffeescript