text:
---
description: Docker Hub programs and policies for publishers
keywords: Docker, docker, store, publishers, publish images
title: Publisher & Certified Content Overview
---

Independent Software Vendors (ISVs) can utilize Docker Hub to distribute and
sell their Dockerized content. Publish your software through Docker Hub to
experience the following benefits:

* **Access to Docker’s large and growing customer-base.** Docker has experienced
  rapid adoption, and is popular in dev-ops environments. Docker users have
  pulled images over twelve billion times and they are increasingly turning to
  Docker Hub as the canonical source for high-quality, curated content.

* **Customers can try or buy your software**, right from your product listing.
  Your content is accessible for installation, trial, and purchase from
  Docker Hub and the Docker CLI.

* **Use of Docker licensing support.** Control who has access to your software:
  a) logged-in users, b) users who have purchased a license, or c) all Docker
  users. We’ll help you manage and control your distribution.

* **We handle checkout.** You don’t need to set up your own digital
  e-commerce site when you sell your content through Docker Hub. Choose
  how much you want to charge for your products and we handle the billing.

* **Seamless updates and upgrades for your customers.** We tell your customers
  when your content has upgrades or updates available.

* **Become Docker Certified.** Publisher container images and plugins that meet
  the quality, security, and support criteria of the program displays a
  “Docker Certified” badge within the Docker Hub (which can be used in
  external marketing).

## Distribution models

Docker Hub welcomes free and open-source content, as well as software sold
directly by publishers. We support the following commercial models:

### Paid through Docker

This commercial model allows customers to pay for ISV content through Docker, as
described in the Store Vendor Partner agreement. Paid-through-Docker content
includes both software that can be deployed on a host, as well as software that
runs in the cloud and can be accessed by the customer through an agent
(containerized cloud services, for example).

### Licensed content through Docker Hub BYOL program

ISVs can use Docker Hub as an entitlement and distribution platform. Using
APIs provided by Docker, ISVs can entitle users and distribute their Dockerized
content to many different audiences:
* Existing customers that want their licensed software made available as Docker containers.
* New customers that are only interested in consuming their software as Docker containers.
* Trial or beta customers, where the ISV can distribute feature or time limited software.

Docker provides a fulfillment service so that ISVs can programmatically entitle
users, by creating subscriptions to their content in Docker Hub. For more
information, see [Bring Your Own License (BYOL) products on Store](byol.md).

### Plugins and agents

ISVs have the ability to create and distribute [plugin images](https://hub.docker.com/search?certification_status=certified&q=&type=plugin) for their customers to integrate with the ISV's proprietary hardware or cloud infrastructure and Docker Enterprise Edition deployments.

You can [apply to be a publisher](https://goto.docker.com/partners) and learn more about our [Technology Partner Program](https://www.docker.com/partners/partner-program#/technology_partner).

## What's next?

* Learn about submitting products and content to Docker Hub, see the [publishers guide](publish.md) and the [publisher FAQs](publisher_faq.md).
* Learn about using Docker Hub to download content, see the [customer FAQs](customer_faq.md).


text:
# ghb0t

[![Travis CI](https://travis-ci.org/genuinetools/ghb0t.svg?branch=master)](https://travis-ci.org/genuinetools/ghb0t)

A GitHub Bot to automatically delete your fork's branches after a pull request
has been merged.

> **NOTE:** This will **never** delete a branch named "master" AND will
**never** delete a branch that is not owned by the current authenticated user.
If the pull request is closed _without_ merging, it will **not** delete it.

## Installation

#### Binaries

- **darwin** [386](https://github.com/genuinetools/ghb0t/releases/download/v0.4.0/ghb0t-darwin-386) / [amd64](https://github.com/genuinetools/ghb0t/releases/download/v0.4.0/ghb0t-darwin-amd64)
- **freebsd** [386](https://github.com/genuinetools/ghb0t/releases/download/v0.4.0/ghb0t-freebsd-386) / [amd64](https://github.com/genuinetools/ghb0t/releases/download/v0.4.0/ghb0t-freebsd-amd64)
- **linux** [386](https://github.com/genuinetools/ghb0t/releases/download/v0.4.0/ghb0t-linux-386) / [amd64](https://github.com/genuinetools/ghb0t/releases/download/v0.4.0/ghb0t-linux-amd64) / [arm](https://github.com/genuinetools/ghb0t/releases/download/v0.4.0/ghb0t-linux-arm) / [arm64](https://github.com/genuinetools/ghb0t/releases/download/v0.4.0/ghb0t-linux-arm64)
- **solaris** [amd64](https://github.com/genuinetools/ghb0t/releases/download/v0.4.0/ghb0t-solaris-amd64)
- **windows** [386](https://github.com/genuinetools/ghb0t/releases/download/v0.4.0/ghb0t-windows-386) / [amd64](https://github.com/genuinetools/ghb0t/releases/download/v0.4.0/ghb0t-windows-amd64)

#### Via Go

```bash
$ go get github.com/genuinetools/ghb0t
```

## Usage

```
$ ghb0t -h
       _     _      ___  _
  __ _| |__ | |__  / _ \| |_
 / _` | '_ \| '_ \| | | | __|
| (_| | | | | |_) | |_| | |_
 \__, |_| |_|_.__/ \___/ \__|
 |___/

 A GitHub Bot to automatically delete your fork's branches after a pull request has been merged.
 Version: v0.4.0
 Build: be7363d

  -d    run in debug mode
  -interval string
        check interval (ex. 5ms, 10s, 1m, 3h) (default "30s")
  -token string
        GitHub API token (or env var GITHUB_TOKEN)
  -v    print version and exit (shorthand)
  -version
        print version and exit
```

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
## This is a C# Winform Application for  Book Brokers.

#### It uses the OleDb objects to interact with the MS Access database tables
#### It uses programming logic (master-detail relationships in conjunction with ‘for-each’ loops) to create the reports

#### This is a front end C# Winform Application for dealers in used books.
#### It allows the users to maintain the records stored in the database and produce the reports that they need.

## For testing:
### You can download the file of "BookManagement.exe" to test this program.

repository: stimulate/Book-Management

repo_name: stimulate/Book-Management


text:
# Collector
The periods to get data for are customized in the code, please find below if you need complete example follow the code in the [commit](https://github.com/akvelon/Bitcoin-Transaction-Optimization/blob/master/nnfee/collector/console.rb#L11).

It a Ruby based application which running in Docker container. There is some code here which allows to train the model but for purpose of BTO we only using code in `collector` folder.

* Install `Docker` for your system (https://docs.docker.com/docker-for-windows/install/)
* Switch container type to Linux (https://docs.docker.com/docker-for-windows/#switch-between-windows-and-linux-containers)

1. Getting the data to analyze
    1. First of all we need to download the metadata for part of blockchain
    This could be done by executing ([collect](https://github.com/akvelon/Bitcoin-Transaction-Optimization/blob/master/nnfee/collect#L3)).
		```
		docker-compose run collector ruby collect.rb
		```
		Followed by updating `$last_block_index` variable (if needed) in `collector/harmony.rb` to the latest

   2. Give script some time to work (approx 100-200 mb in `/data/collector/data` should be enough to start) it will also load the  `/data/collector/mempool.log` (which is what got from [here](https://jochen-hoenicke.de/queue/mempool.log) - note, this is file more than 700 Mb) with mempool characteristics logged each minute.

   3. After that just stop the execution (unless you want the whole blockchain which is more than 200Gb in that form of metadata blocks) by hitting `Ctrl-C` in console window
2. Next we need combine information from blockchain and mempool statistics.
	1. This is done by executing prepare script with command (copy exactly with quotes, the line of code also live in `prepare` file in the root)
		```
		docker-compose run collector ruby prepare.rb "$@"
		```
		Followed by updating the periods you need to analyze (on the top of `/collector/prepare.rb`)
It will create json representation of mempool log and also read the blockchain metadata, then all data processed, saved some intermediate output to slim db (files in `/data/collector/slim`) and final result to `/data/collector/out/*training.csv`

## Questions\answers
1. **Which data saved to slim db?**
    * The one which is returned in hashes from `/collector/src/utils.rb::raw_read_with_mempool()`
    ![hash data](images/collector/hashData.png)
	* **If you need to update the transactions info saved** then you need also remove the `/data/collector/slim/*` files, otherwise no new info appear.

2. **How can I choose which features to include into output csv?**
   * Just update the list of keys in `/collector/prepare.rb` this will add the columns to output file in order specified
    ![feature keys](images/collector/featureKeys.png)

		Possible options for keys are info in transactions which is combination of data we pushed to slim db and some which added in `collector/prepare.rb` loop like `add_confirmation_speed` defined in `/collector/src/utils.rb`

	![tx sample data](images/collector/txSampleData.png)

3. **What we have in metadata for blocks and transaction which might not be pushed to slim db?**
   * Check out the `/collector/src/utils.rb::block_stats()` for more info
    ![block stats](images/collector/blockStats.png)

4. **My output is blank for period, why?**
   * It likely because there is no related mempool info in the `mempool.json`
     1. Make sure that specified period of time is described in mempool.log. You might be need to download the recent version from the site (or just remove the file and allow script do its work).
     2. Check mempool start time in `docker-compose.yml` it should start before the time period you want to collect.
     3. Remove the `mempool.json` file among with `/data/collector/slim/*` files and start prepare script one more time.

gha_language: Jupyter Notebook


text:
### ytt Library: Library annotations

Available in v0.28.0+

- `#@library/ref`: Attaches a yaml document to the specified library to be used during evalutaion via the library module (only supported for [data value documents](./ytt-data-values.md#library-setting-via-files))

```yaml
#@library/ref "@app"
#@data/values
---
name: "app1"
```

Note: data values may also be attached to libraries via [command line flags](ytt-data-values.md#library-setting-via-cmd)

### ytt Library: Library module

Library module `@ytt:library` provides a way to programmatically get result of templates included in a library. Libraries are found within `_ytt_lib` subdirectory.

- `load("@ytt:library", "library")`
```python
# build library instance
app1 = library.get("app")

# build new copy of library with data values (does not mutate app1)
app1_with_vals = app1.with_data_values({"name": "app1"})

# return results of all YAML templates
app1_with_vals.eval()

# return url function defined within app library
url_func = app1_with_vals.export("url")
url_func() # result of url function
```

- `library.get(name, [alias=, ...])` (`name`: string, returned: library): returns library object that is backed by content under `_ytt_lib/<name>` (found in the same directory as the file containing this call). `name` could contain '/' slashes for directories (e.g. `github.com/k14s/k8s-lib/app`).
  - Keyword arguments:
    - `alias=<string>` (no default) can be used to specify unique name for this library instantiation.
    - `ignore_unknown_comments=<bool>` (default False) equivalent to `ytt --ignore-unknown-comments`. Available v0.31.0+
    - `implicit_map_key_overrides=<bool>` (default False) equivalent to `ytt --implicit-map-key-overrides`. Available v0.31.0+
    - `strict=<bool>` (default False) equivalent to `ytt --strict`. Available v0.31.0+

- `x.with_data_values(vals)` (`x`: library, `vals`: dict or YAML fragment, returned: library): returns a new library copy with added data values. Given data values are overlayed on top of data values found within library.

```yaml
#@ def app_vals():
name: app1
env_vars:
  #@overlay/match missing_ok=True
  custom_key: val
#@ end

#! with_data_values
#@ app1_with_vals = app1.with_data_values(app_vals())
```

- `x.eval()` (`x`: library, returned: YAML document set): returns computed YAML document set based on library configuration and data values.

- `x.export(name, [path=])` (`x`: library, `name`: string, `path`: string, returned: any value including function): returns value of a symbol found within a library. Typically used to export a function but could also be used for variables. `path` keyword argument can specify location for the symbol if name is not unique within a library (`path` should not be used unless there are multiple symbols with the same name).

```python
url_func = app1_with_vals.export("url", path="config.lib.yml")
```

Available in v0.28.0+

- `x.data_values()` (`x`: library, returned: data values): returns the data values of the library instance.

```python
app_values = app1_with_vals.data_values()
```

#### Examples

See [ytt-library-module example](../examples/playground/example-ytt-library-module).

branch_name: refs/heads/develop

gha_language: HTML


text:
CHANGELOG
=========

### Legend

* "BC": Backwards compatibility break (from public component APIs)
* "BF": Bug fix

---

* 0.4.4 (2021-12-11)
  * Correct and update dependencies for forward compatibility
  * Added context for React Socket server to App
  * Use non-deprecated Guzzle API calls

* 0.4.3 (2020-06-04)
  * BF: Fixed interface acceptable regression in `App`
  * Update RFC6455 library with latest fixes

* 0.4.2 (2020-01-27)
  * Support Symfony 5
  * BF: Use phpunit from vendor directory
  * Allow disabling of xdebug warning by defining `RATCHET_DISABLE_XDEBUG_WARN`
  * Stop using `LoopInterface::tick()` for testing

* 0.4.1 (2017-12-11)
  * Only enableKeepAlive in App if no WsServer passed allowing user to set their own timeout duration
  * Support Symfony 4
  * BF: Plug NOOP controller in connection from router in case of misbehaving client
  * BF: Raise error from invalid WAMP payload

* 0.4 (2017-09-14)
  * BC: $conn->WebSocket->request replaced with $conn->httpRequest which is a PSR-7 object
  * Binary messages now supported via Ratchet\WebSocket\MessageComponentInterface
  * Added heartbeat support via ping/pong in WsServer
  * BC: No longer support old (and insecure) Hixie76 and Hybi protocols
  * BC: No longer support disabling UTF-8 checks
  * BC: The Session component implements HttpServerInterface instead of WsServerInterface
  * BC: PHP 5.3 no longer supported
  * BC: Update to newer version of react/socket dependency
  * BC: WAMP topics reduced to 0 subscriptions are deleted, new subs to same name will result in new Topic instance
  * Significant performance enhancements

* 0.3.6 (2017-01-06)
  * BF: Keep host and scheme in HTTP request object attatched to connection
  * BF: Return correct HTTP response (405) when non-GET request made

* 0.3.5 (2016-05-25)
  * BF: Unmask responding close frame
  * Added write handler for PHP session serializer

* 0.3.4 (2015-12-23)
  * BF: Edge case where version check wasn't run on message coalesce
  * BF: Session didn't start when using pdo_sqlite
  * BF: WAMP currie prefix check when using '#'
  * Compatibility with Symfony 3

* 0.3.3 (2015-05-26)
  * BF: Framing bug on large messages upon TCP fragmentation
  * BF: Symfony Router query parameter defaults applied to Request
  * BF: WAMP CURIE on all URIs
  * OriginCheck rules applied to FlashPolicy
  * Switched from PSR-0 to PSR-4

* 0.3.2 (2014-06-08)
  * BF: No messages after closing handshake (fixed rare race condition causing 100% CPU)
  * BF: Fixed accidental BC break from v0.3.1
  * Added autoDelete parameter to Topic to destroy when empty of connections
  * Exposed React Socket on IoServer (allowing FlashPolicy shutdown in App)
  * Normalized Exceptions in WAMP

* 0.3.1 (2014-05-26)
  * Added query parameter support to Router, set in HTTP request (ws://server?hello=world)
  * HHVM compatibility
  * BF: React/0.4 support; CPU starvation bug fixes
  * BF: Allow App::route to ignore Host header
  * Added expected filters to WAMP Topic broadcast method
  * Resource cleanup in WAMP TopicManager

* 0.3.0 (2013-10-14)
  * Added the `App` class to help making Ratchet so easy to use it's silly
  * BC: Require hostname to do HTTP Host header match and do Origin HTTP header check, verify same name by default, helping prevent CSRF attacks
  * Added Symfony/2.2 based HTTP Router component to allowing for a single Ratchet server to handle multiple apps -> Ratchet\Http\Router
  * BC: Decoupled HTTP from WebSocket component -> Ratchet\Http\HttpServer
  * BF: Single sub-protocol selection to conform with RFC6455
  * BF: Sanity checks on WAMP protocol to prevent errors

* 0.2.8 (2013-09-19)
  * React 0.3 support

* 0.2.7 (2013-06-09)
  * BF: Sub-protocol negotation with Guzzle 3.6

* 0.2.6 (2013-06-01)
  * Guzzle 3.6 support

* 0.2.5 (2013-04-01)
  * Fixed Hixie-76 handshake bug

* 0.2.4 (2013-03-09)
  * Support for Symfony 2.2 and Guzzle 2.3
  * Minor bug fixes when handling errors

* 0.2.3 (2012-11-21)
  * Bumped dep: Guzzle to v3, React to v0.2.4
  * More tests

* 0.2.2 (2012-10-20)
  * Bumped deps to use React v0.2

* 0.2.1 (2012-10-13)
  * BF: No more UTF-8 warnings in browsers (no longer sending empty sub-protocol string)
  * Documentation corrections
  * Using new composer structure

* 0.2 (2012-09-07)
  * Ratchet passes every non-binary-frame test from the Autobahn Testsuite
  * Major performance improvements
  * BC: Renamed "WampServer" to "ServerProtocol"
  * BC: New "WampServer" component passes Topic container objects of subscribed Connections
  * Option to turn off UTF-8 checks in order to increase performance
  * Switched dependency guzzle/guzzle to guzzle/http (no API changes)
  * mbstring no longer required

* 0.1.5 (2012-07-12)
  * BF: Error where service wouldn't run on PHP <= 5.3.8
  * Dependency library updates

* 0.1.4 (2012-06-17)
  * Fixed dozens of failing AB tests
  * BF: Proper socket buffer handling

* 0.1.3 (2012-06-15)
  * Major refactor inside WebSocket protocol handling, more loosley coupled
  * BF: Proper error handling on failed WebSocket connections
  * BF: Handle TCP message concatenation
  * Inclusion of the AutobahnTestSuite checking WebSocket protocol compliance
  * mb_string now a requirement

* 0.1.2 (2012-05-19)
  * BC/BF: Updated WAMP API to coincide with the official spec
  * Tweaks to improve running as a long lived process

* 0.1.1 (2012-05-14)
  * Separated interfaces allowing WebSockets to support multiple sub protocols
  * BF: remoteAddress variable on connections returns proper value

* 0.1 (2012-05-11)
  * First release with components: IoServer, WsServer, SessionProvider, WampServer, FlashPolicy, IpBlackList
  * I/O now handled by React, making Ratchet fully asynchronous

repository: tsugiproject/tsugi

gha_language: PHP

repo_name: tsugiproject/tsugi


text:
# Bootstrap helpers [![Build Status](https://secure.travis-ci.org/chrisbo246/bootstrap-helpers.svg?branch=master)](http://travis-ci.org/chrisbo246/bootstrap-helpers) [![Coverage Status](https://coveralls.io/repos/chrisbo246/bootstrap-helpers/badge.png?branch=master)](https://coveralls.io/r/chrisbo246/bootstrap-helpers?branch=master)

Missing CSS and common JS.

## Features

See [website](http://chrisbo246.github.io/bootstrap-helpers/).

## Getting Started

### Installing

Download with Bower.

```
bower install chrisbo246/bootstrap-helpers
```

Insert the **bootstrap-helpers.js** in your index.html

```
<script src="/bower_components/bootstrap-helpers/dist/scripts/bootstrap-helpers.js"></script>
```

Edit your main.scss and insert **bootstrap-helpers.scss** just after Bootstrap.

```
@import "bootstrap";
@import "app/styles/bootstrap-helpers";
```

## Development

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

### Prerequisites

Install [Node](https://nodejs.org/en/download/) on your local machine then download dependencies.

```
npm install -g gulp-cli bower yo generator-webapp
```

### Installing

Install NPM and Bower packages.

```
npm install
bower install
```

### Testing

```
gulp serve
```

[http://localhost:9000/](http://localhost:9000/)

## Deployment

```
gulp build
```

Then upload the **dist** directory content to your web server.

<!--

## Contributing

Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on our code of conduct, and the process for submitting pull requests to us.

-->

## Bugs

Please use the [GitHub issue tracker](https://github.com/chrisbo246/bootstrap-helpers/issues) for all bugs and feature requests. Before creating a new issue, do a quick search to see if the problem has been reported already.

## Author

[chrisbo246](https://github.com/chrisbo246)

See also the list of [contributors](https://github.com/chrisbo246/bootstrap-helpers/contributors) who participated in this project.

## License

This project is licensed under the MIT License. See the [opensource.org](https://opensource.org/licenses/MIT) website for details.


text:
# DAM in AN AI First World Tech Lab Adapt To 2020 - Instruction

- [DAM in AN AI First World Tech Lab Adapt To 2020 - Instruction](#dam-in-an-ai-first-world-tech-lab-adapt-to-2020---instruction)
  - [Adding Credentials - Custom Worker Contd](#adding-credentials---custom-worker-contd)
    - [Developer Tool Credentials](#developer-tool-credentials)
    - [Local Development](#local-development)
      - [Pre-requisites](#pre-requisites)
      - [Running the example Application](#running-the-example-application)
      - [Debug](#debug)
      - [Test](#test)
      - [Adding Worker Tests](#adding-worker-tests)
      - [Deploy (This is not required for this lab)](#deploy-this-is-not-required-for-this-lab)
- [Content and Commerce AI overview](#content-and-commerce-ai-overview)
  - [Color Extraction](#color-extraction)
    - [Getting Started](#getting-started)
      - [Create a Processing Profile](#create-a-processing-profile)
      - [Update Metadata Schema to support output of your Custom Worker](#update-metadata-schema-to-support-output-of-your-custom-worker)
      - [Associate Processing Profile with Folder](#associate-processing-profile-with-folder)
  - [Keyword  Extraction (To be updated this week )](#keyword-extraction-to-be-updated-this-week-)

## Adding Credentials - Custom Worker Contd

Since you logged in during app creation, most of the credentials are already collected in your `.env` file.If you face any issue contact lab instructor.

### Developer Tool Credentials

**Pre-requisite** Make sure that you have access to a cloud storage container. Currently, we only support Azure Blob Storage and AWS S3.

*Note: This can be a shared container used by multiple developers across different projects.*

Add the following credentials to the `.env` file in the root of your Firefly project:

1. Add the absolute path to the private key file created while adding services to your Firefly Project:

   ```
   ASSET_COMPUTE_PRIVATE_KEY_FILE_PATH=
   ```

2. Add either S3 or Azure Storage credentials. (You only need access to one cloud storage solution(if you have ,else use the below credential)):

   ```
   # S3 credentials
   S3_BUCKET=
   AWS_ACCESS_KEY_ID=
   AWS_SECRET_ACCESS_KEY=
   AWS_REGION=

   # Azure Storage credentials
   AZURE_STORAGE_ACCOUNT=sanmishrblobs
   AZURE_STORAGE_KEY='D0IISFPFe4tp1IGbl9r8ZrZSCNBDbJVhHHa0icRU2Nm5AIa6TKMkaRJkxB7NupIAIuwHNvP6qKEVOGe9I4emoA=='
   AZURE_STORAGE_CONTAINER_NAME=adapttoblobs
   ```

### Local Development

#### Pre-requisites

- Make sure to properly configure the [development tool credentials](https://git.corp.adobe.com/nui/nui/blob/master/doc/developer/CustomWorkerDeveloperGuide.md#developer-tool-credentials) in the `.env` file.
- Make sure to have [docker desktop](https://www.docker.com/products/docker-desktop) installed and running on your machine. You need docker running to run the worker tests

#### Running the example Application

This example app / worker sends a local image to blob storage. Afterwards you can select it in the dropdown and click on run. This will start the Adobe I/O worker / action, calculate a dummy rendition and send it back to your machine.

To run the application, use the following command:

```
aio app run
```

This will deploy the action to Adobe I/O Runtime and start the development tool on your local machine. This tool is used for testing worker requests during development. Here is an example rendition request:

```
"renditions": [
    {
        "worker": "https://1234_my_namespace.adobeioruntime.net/api/v1/web/example-custom-worker-master/worker",
        "name": "image.jpg"
    }
]
```

*Note: Do not use the `--local` flag with the run command. It does not work with Asset Compute custom workers and the Asset Compute Developer Tool. Custom workers are invoked by the Asset Compute Service which cannot access actions running on developer's local machines.*

#### Debug

#### Test

To test the worker, run the following command:

```bash
aio app test
```

#### Adding Worker Tests

To add additional worker tests, follow the guidlines [here](https://git.corp.adobe.com/nui/nui/blob/master/doc/developer/AddWorkerTests.md).

#### Deploy (This is not required for this lab)

To deploy the worker, run the following command (This is not required for this lab):

```bash
aio app deploy
```

# Content and Commerce AI overview

Content and Commerce AI is a set of AI services that allow you to extract intelligent features from your content, organize and streamline content flow, and deliver more impactful, personalized experiences to your customers.

All brands strive to deliver a perfect customer experience. You're constantly trying to find better answers all aspects of your customer touchpoints.

Content is an essential component of these experiences. To better answer marketing questions, you must understand content and your customers' interactions with it. With Content and Commerce AI, you can learn what features of the content you provide resonates with your customers. Using these insights allows you to personalize experiences and boost KPIs.

You can find more details about it [here](https://docs.adobe.com/content/help/en/experience-platform/intelligent-services/content-commerce-ai/overview.html).

This is Still in Beta, below we will try 2 features from this API

- Color Extraction
- Keyword Extraction

## Color Extraction

The color extraction service, when given an image, can compute a histogram of pixel colors and sort them by dominant colors into buckets. The colors in the image pixels are bucketed into 40 predominant colors which are representative of the color spectrum. A histogram of color values is then computed among those 40 colors.

Please take a look at the [Official Color Extraction Documentation](https://docs.adobe.com/content/help/en/experience-platform/intelligent-services/content-commerce-ai/api/color-extraction.html) to understand the used code fragments from the workers 'index.js'.

> ⚠ *analyzer_id* determines which Sensei Content Framework is used. Please check that you have the proper analyzer_id before making your request. For color extraction service, the analyzer_id ID is: *Feature:image-color-histogram:Service-6fe52999293e483b8e4ae9a95f1b81a7*

### Getting Started

1. Go To project inside  [Console.adobe.io](https://console.adobe.io/projects)

2. Make sure you have selected adobe-odyssee as your current organisation

3. Depending on your assignment  open AEM-pxxx-exxx91 project   (There are 6 lab env named adaptto2020-1 to  adaptto2020-6 you can be assigned to any one of them for this lab )

   ![image-20200927210820016](Lab/image-20200927210820016.png)

4. Click Download on the top right corner / or use the ones provided directly in this repository.
   - [index.js](./index.js)
   - [manifest.yml](./manifest.yml)
   - [package.json](./package.json)

   ![image-20200907195151095](Lab/image-20200907195151095.png)

5. Replace the content of `\your-project\actions\worker\index.js` and adapt the content of `\your-project\package.json` accordingly

   - Note, do not replace package.json as is, only add the missing dependecies .

6. Go to the parent / root directory of the project and execute npm install (`npm i`) it will update the project with its missing depedencies.

7. Update the following values in your local `.env` file. Doing this, will allow us to deploy to an already set up AEM instance.
   1. **Note**: you can alternativly execute `aio use <path/to/config.json> - which will be provided by the LAB leader.They are inside a folder named [**env_file**](https://github.com/houseofai/adaptto2020-aiworkshop/tree/master/DAM-Workshop/env_file) (For Sanity of this lab use only the env you are assigned with )
   2. AIO_ims_contexts_Project__1600253157454J_client__id=
   3. AIO_ims_contexts_Project__1600253157454J_client__secret=
   4. AIO_ims_contexts_Project__1600253157454J_technical__account__email=
   5. AIO_ims_contexts_Project__1600253157454J_technical__account__id=
   6. AIO_ims_contexts_Project__1600253157454J_meta__scopes=
   7. AIO_ims_contexts_Project__1600253157454J_ims__org__id=

8. `aio app deploy` // *this will deploy the application*

9. If you make any changes, run `aio app undeploy` first.

   ![image-20200907200539570](Lab/image-20200907200539570.png)

   Note the URL endpoint for your new Firefly App. We’ll use this when creating a processing profile in AEM

#### Create a Processing Profile

1. From the AEM > Tools > Assets > Processing Profiles
2. Click Create
3. Give your Processing Profile a title, and then click on "Custom" tab
4. Enable "Create Metadata Rendition" toggle
5. For "Endpoint URL" input the URL of the worker as seen after running aio app deploy for your Firefly application

     ![clip_image001](Lab/clip_image001.png)

6. Click on Save

#### Update Metadata Schema to support output of your Custom Worker

**Note**: this schema should be configured/customized to meet your own use case. The instructions below are to support the simple color extraction custom worker included.

- From the AEM > Tools > Assets > Metadata Schemas
- Select "default"
- Click on Edit
- Click on + to add a new Sensei CCAI tab
- Click on "Build Form"
- Drag "Multi Value Text" on the form
  - Name: Color Names
  - Map to      property: ./jcr:content/metadata/ccai:colorNames
- ![image-20200927211324122](Lab/image-20200927211324122.png)

- Click on "Build Form" again, Drag "Multi Value Text" on the form
  - Name: Color RGB
  - Map to      property: ./jcr:content/metadata/ccai:colorRGB

- Click on Save

#### Associate Processing Profile with Folder

- From the AEM > Navigation > Assets
- Create a folder for testing this worker,     if one does not exist
- Hover the folder and click the check mark
- Click "Properties" in the top     pane
- Click "Asset Processing" and     select the new Processing Profile that you created in the previous steps

 ![clip_image003](Lab/clip_image003.png)

- Click Save

**Test it!**

- Upload a PNG or JPG to the folder that     you set up in Step 2.
- Wait for the asset to stop processing
- Hover over the asset and click on the i
  - Or alternatively select the asset and      click on Properties
- Switch to the Sensei CCAI Color  tab

- You should see the list of extracted     colors

  <img src="Lab/image-20200927210356025.png" alt="image-20200927210356025" style="zoom:150%;" />

## Keyword  Extraction

Example of a custom Asset Compute Metadata worker leveraging the [Content and Commerce AI](https://docs.adobe.com/content/help/en/experience-platform/intelligent-services/content-commerce-ai/overview.html) Keyword  extraction API from PDF .

The worker is based on [Project Firefly](https://github.com/AdobeDocs/project-firefly) and the [aio](https://github.com/adobe/aio-cli) developer tool.Copy the content of worker-ccai-keywordextract.js into yours index.js.

## Metadata

The worker returns the following metadata from the recognized list of named entities from the [keyword extraction API](https://docs.adobe.com/content/help/en/experience-platform/intelligent-services/content-commerce-ai/api/keyword-extraction.html).

| Name                      | Metadata Type           | Description                                                  |
| ------------------------- | ----------------------- | ------------------------------------------------------------ |
| `ccai:entityKeyword`      | Multi Value Text        | List of keywords                                             |
| `ccai:entityOrganization` | Multi Value Text        | List of companies, agencies, institutions                    |
| `ccai:entityProduct`      | Multi Value Text        | List of objects, vehicles, foods, etc. (Not services)        |
| `ccai:entityPerson`       | Multi Value Text        | List of people, including fictional.                         |
| `ccai:entityLocation`     | Multi Value Text        | List of countries, cities, states, mountain ranges, and bodies of water. |
| `ccai:entityName`         | Multi Value Text        | List of entity names in order of highest score to lowest score |
| `ccai:entity`             | Sequence of XMP structs | List of entity features, with fields `ccai:name`, `ccai:type`, and `ccai:score`. Intended for advanced AEM customizations. |

The lists have the same order and are sorted from high to low score percentage.

## Deploy

- Download the sources of this worker files from [here](https://github.com/houseofai/adaptto2020-aiworkshop/tree/master/text-worker-master)

- Go to the `tex-worker-master` directory

- Run `npm install`

- Run

  ```
  aio app use <Path to Adobe I/O Developer Console configuration file> (you can get it from env_file)
  ```

  - This will setup your `.env` to point at the Firefly project and workspace

- Run `aio app deploy` to deploy the application

### Review logs

- Use `aio app logs` to review the logs of the most recent invocation

## Integrating with AEM Cloud Service

### Create a Processing Profile

- From the AEM homepage, navigate to Tools -> Assets -> Processing profiles -> Create
- Select the Custom tab
- Enable *Create Metadata Rendition*
- For *Endpoint URL*, input the URL of the worker as seen after running `aio app deploy`
- Click on Save

### Associate Processing Profile with Folder

- Select the created Processing Profile
- Click on *Apply Profile to Folder(s)*
- Select a folder
- Click on *Apply*

### Update Metadata Schema

- From the AEM homepage, navigate to Tools -> Assets -> Metadata Schemas
- Select an existing schema like *default* and click on *Edit* or click *Create*
- Click on `+` to add a new *Content and Commerce AI* tab like ccai-keyword tab
- Create new metadata schema as mentioned inside MetaData table
- For refernce you can follow this existing schema

![image-20200927220835057](Lab/image-20200927220835057.png)

![image-20200927220909537](Lab/image-20200927220909537.png)

Click on save once you are done .

### End to end test

-  Upload a pdf file
-  Wait for the asset to stop processing
-  Click on the asset
-  Click on Properties
-  Click on save once you are done
-  Switch to the CCAI-Keyword tab

![image-20200927221341931](Lab/image-20200927221341931.png)

-  In case you don't see the metadata reprocess it

![image-20200927221601164](Lab/image-20200927221601164.png)

###


text:
[![NuGet Badge](https://buildstats.info/nuget/Meadow.Foundation)](https://www.nuget.org/packages/Meadow.Foundation)
[![Develop Branch](https://github.com/WildernessLabs/Meadow.Foundation/actions/workflows/develop-ci.yml/badge.svg)](https://github.com/WildernessLabs/Meadow.Foundation/actions/workflows/develop-ci.yml)

<img src="Design/meadow.foundation.jpg" alt="iot, dotnet, meadow, meadow-foundation"  style="margin-bottom:10px" />

# Meadow.Foundation

The [Meadow.Foundation](http://developer.wildernesslabs.co/Meadow/Meadow.Foundation/Peripherals/) peripherals library is an open source repository of drivers and libraries that streamline and simplify adding hardware to your .NET Meadow IoT application.

Meadow.Foundation makes the task of building connected things easy with Meadow by providing a unified driver and library framework that includes drivers and abstractions for common peripherals such as: sensors, displays, motors, cameras and more. Additionally, it includes utility functions and helpers for common tasks when building connected things.

## Contents

* [Repositories](#repositories)
* [Repository Branches](#repository-branches)
  * [Main](#main)
  * [Develop](#develop)
  * [Branch History](#branch-history)
* [Requesting New Drivers](#requesting-new-drivers)
* [Documentation](#documentation)
* [Using Meadow.Foundation](#using-meadowfoundation)
* [Contributing](#contributing)
* [License](#license)
* [Author Credits](#author-credits)

## Repositories

Meadow.Foundation is currently split into multiple GitHub repos:
1. [Meadow.Foundation](https://github.com/WildernessLabs/Meadow.Foundation/) which contains the majority of the peripheral and library source code
2. [Meadow.Foundation.Featherwings](https://github.com/WildernessLabs/Meadow.Foundation.Featherwings/) contains drivers for hardware that conforms to the [Adafruit Featherwing](https://learn.adafruit.com/adafruit-feather/) form factor
3. [Meadow.Foundation.Grove](https://github.com/WildernessLabs/Meadow.Foundation.Grove/) contains drivers for [Seeed Studio Grove](https://www.seeedstudio.com/grove.html) modular hardware peripherals
4. [Meadow.Foundation.MikroBus](https://github.com/WildernessLabs/Meadow.Foundation.mikrobus/) contains drivers for [MikroElektronika](https://www.mikroe.com/click)  mikroBUS Click Boards

## Repository Branches

Today, Meadow.Foundation is represented within two branches: `main` and `develop`.

### Main

The `main` branch represents the currently published code from the last official release. Meadow.Foundation projects that depend on other projects within Meadow.Foundation will have local project references. For example, display drivers will contain a project reference to MicroGraphics. Any references outside of Meadow.Foundation rely on the latest published nuget packages. Nuget references are typically only present in the Meadow.Foundation sample projects.

The `main` branch will compile without the need to clone additional projects. This branch is ideally used to review driver structure and run driver samples with the latest published and stable code.

### Develop

The `develop` branch represents the current state of development for the next official release. Code in this branch should be tested and functional. However, changes in this branch may depend on changes in other Meadow projects, such as Meadow Core.

To compile the `develop` branch, you'll need to clone other dependency GitHub repositories at the same folder level as Meadow.Foundation. This includes but is not limited to: Meadow.Core, Meadow.Units, Meadow.Contracts, Meadow.Logging, and Meadow.Modbus. You can review the references in the `_external` solution folder within Meadow.Foundation for the complete list. Typically, all dependency projects should also be on the `develop` branch. This branch is ideal if you want to submit new drivers or propose substantial changes to existing code.

### Branch history

All code changes are committed to the `develop` branch. At the time of release, the references within develop are updated for publishing and then merged to `main`. This ensures a consistent and accurate history across `develop` and `main`. This also allows pull requests targeted to `main` to be easily retargeted to `develop`.

## Requesting New Drivers

If you have a need for a driver that we don't yet support, you have a couple options:

- Use an existing, similar driver as a template for your new driver.  We accept pull requests, but don't require them.
- Open a new item on the [Issues Tab](https://github.com/WildernessLabs/Meadow.Foundation/issues) and request the driver so we can prioritize it.

## Documentation

You can read more Meadow.Foundation and how to get started in our [developer site](http://developer.wildernesslabs.co/Meadow/Meadow.Foundation/).

## Using Meadow.Foundation

To use Meadow.Foundation, simply add a Nuget reference to the core library (for core helpers and drivers), or to the specific peripheral driver you'd like to use, and the core will come with it.

```bash
nuget install Meadow.Foundation
```

## Contributing

Meadow.Foundation, is open source and community powered. We love pull requests, so if you've got a driver to add, send it on over! For each peripheral driver, please include:

 * **Documentation** - Including a Fritzing breadboard schematic on wiring it up, sourcing info, and API docs. Please see other drivers for examples. Documentation is hosted on the Wilderness Labs [DocFx](https://wildernesslabs.github.io/docfx/) site.
 * **Datasheet** - For the peripheral, if applicable.
 * **Sample** - Application illustrating usage of the peripheral.

## License

Copyright 2019-2023, Wilderness Labs Inc.

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

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

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

## Author Credits

Authors: Bryan Costanich, Mark Stevens, Adrian Stevens, Jorge Ramirez, Brian Kim, Frank Krueger, Craig Dunn

gha_language: C#


text:
---
title: Server maintenance
date: 2020-08-03T12:10:42
author: Sebastian Sdorra
categories:
- infrastructure
keywords:
- infrastructure
- server
- jenkins
- nexus
---

On Thursday 06-08-2020 at 07:00 GMT+2 we will update the following parts of our infrastructure:

* oss.cloudogu.com
* packages.scm-manager.org

This can cause interruptions when downloading SCM-Manager and installing or updating plugins.
The maintenance work should not take longer than a few hours.

repository: robertauer/website

repo_name: robertauer/website


text:
[![Build Status](https://travis-ci.org/mmrath/coalescing_buffer.svg?branch=master)](https://travis-ci.org/mmrath/coalescing_buffer)

# Rust Coalescing Ring Buffer

An attempt to port Java [Coalescing Ring Buffer](https://github.com/LMAX-Exchange/LMAXCollections) to Rust

# TO DO

* Add documentation
* Compare with Java performance


text:
## Synapse-Analytics-Azure-DW-Automation-one-click-template-using-just-ADF-v2

If you are using Azure DW today , you may be using combination of multiple services like Azure function\logic apps , ADF , Rest API call to automate the Azure DW  .

With the help of new authentication method “MSI” in ADF,  you can automate this with just ADF v2.

This Data factory pipeline template is best way to autoimate the Azure DW for below reason:

•	Simple to manage and deploy with few clicks.
•	Simplified solution than existing solution ,as you don’t need extra services like Azure function or logic apps  ,which would avoid provisioning extra services just to manage the Azure DW.
•	Rest call with MSI from ADF is synchronous , this would help to build interdependent steps in pipeline without need of another activity to check the Azure DW status

Download [attached ADF template](https://github.com/nikris87/Synapse-Analytics-Azure-DW-Automation-one-click-template-using-just-ADF-v2/blob/master/Azure_DW_Automation.zip) , you can import this to ADF and start using it. Below are the couple of steps.

## Pre requisite :

Manage ADF MSI permission in Azure DW logical server :

1.	Retrieve  MSI id from ADF :
Data factory resource page--> Properties Tab--> Copy Managed Identity Application ID
2.	Grant permission to ADF MSI in azure DW logical server:
Azure logical server -->Access control (IAM)--> Add Role assignment ->Choose role as 'Contributor'-->Select tab paste MSI id copied in previous step --> Choose the adfname listed--> save

## One click deployment :

1.	Goto ADF template gallery.
2.	Click on "Use local template " and choose the template that you downloaded(Zip file).
3.	Once its deployed update Parameters(Subscription id, Resource Group name, server name ,DB name)  for your environment and your pipeline is ready to use.

you  can use few or all required activity's from template once you deploy.

![ADF v2 and AzureDW](https://github.com/nikris87/Synapse-Analytics-Azure-DW-Automation-one-click-template-using-just-ADF-v2/blob/master/adfv2_AzurDW.jpg)


text:
### Is 1 an arithmetic expression?
Yes

### Is 3 an arithmetic expression?
Yes

### Is 1 + 3 an arithmetic expression?
Yes

### Is 1 + 3 x 4 an arithmetic expression?
Yes

### Is cookie an arithmetic expression?
Yes

### And, what about 3^Y + 5?
Yes

### What is an arithmetic expression in your words?
For the purpose of this chapter, an
arithmetic expression is either an atom (including numbers),
or two arithmetic expressions combined by `+`, `x`, or `expt`.

### What is `(quote a)`
a

### What is `(quote +)`
+

### What does `(quote x)` stand for?
The atom `x`

### Is `(eq? 'a y)` true or false where `y` is a
True

### Is (eq? x y) true or false where `x` is a and `y` is a
True

### Is (n + 3) an arithmetic expression?
Not really, since there are parentheses around n + 3.
Our definition of arithmetic expression does not mention parentheses.

### Could we think of (n + 3) as an arithmetic expression?
Yes

### What would you call (n + 3)?
We call it a representation for n + 3.

### Why is (n + 3) a good representation?
Because
* (n + 3) is an S-expression. It can therefore serve as an argument for a function.
* it's pretty similar to the original.

### True or false: `(numbered? x)` where x is 1
True

### How do you represent 3 + 4 x 5
(3 + (4 x 5))

### True or false: `(numbered? y)` where y is (3 + (4 ^ 5))
True

### True or false: `(numbered? z)` where z is (2 x sausage)
False

### What is numbered?
It's a function that receives an arithmetic expression as an argument
and checks if all the arithmetic expressions are numbers besides the operations, + x ^

### Now can you write a skeleton for `numbered?`
```
(define numbered?
  (lambda (aexp)
    (cond
      (-- ---)
      (--- ---)
      (--- ---)
      (--- --)
    )
  )
)
```

### What is the first question?
`atom? aexp`

### What is (eq? (car (cdr aexp)) '+)
The second question, it checks if the second element of `aexp` is the atom `+`

### Can you guess the third one?
`(eq? (car (cdr aexp)) 'x)`

### And you must know the fourth one.
`(eq? (car (cdr aexp)) '^)`

### Should we ask another question about `aexp`
No! So we could replace the previous question by `else`.

### Why do we ask four, instead of two, questions about arithmetic expressions?
### After all, arithmetic expressions like (1 + 3) are lats.
Because we consider (1 + 3) as a representation of an arithmetic expression in list form, not as a list itself.
And, an arithmetic expression is either a number, or two arithmetic expressions combined by +, x,or t.

### Now you can almost write numbered?
```
(define numbered?
  (lambda (aexp)
    (cond
      ((atom? aexp) (number? aexp))
      ((eq? (car (cdr aexp)) '+)
        (and
          (numbered? (car aexp))
          (numbered? (car (cdr (cdr aexp))))
        )
      )
      ((eq? (car (cdr aexp)) 'x)
        (and
          (numbered? (car aexp))
          (numbered? (car (cdr (cdr aexp))))
        )
      )
      (else
        (and
          (eq? (car (cdr aexp)) '^)
            (and
              (numbered? (car aexp))
              (numbered? (car (cdr (cdr aexp)))))
        )
      )
    )
  )
)
```

### Why do we ask `(number? aexp)` when we know that aexp is an atom?
Because a word is also an atom and we just want numbers

### What do we need to know if the aexp consists of two arithmetic expressions combined by +
We need to know if the two arithmetic expressions are numbers

### In which position is the first subexpression?
Its the `car` of exp

### In which position is the second subexpression?
Its the `car` of `cdr` of `cdr` of exp

### So what do we need to ask?
If `car` of exp and `car` of `cdr` of `cdr` of exp are numbered?
```
(and (numbered? (car aexp))
  (numbered? (car (cdr (cdr aexp))))
)
```

### Since aexp was already understood to be an arithmetic expression, could we have written numbered? in a simpler way?
Yes
```
(define numbered?
  (lambda (aexp)
    (cond
      ((atom? aexp) (number? aexp))
      (else
        (and
          ((numbered? (car aexp)))
          (numbered? (car (cdr (cdr aexp))))
        )
      )
    )
  )
)
```

### What is `(value u)` where u is 13
13

### `(value x)` where x is (1 + 3)
4

### `(value y)` where y is (1 + (3 ^ 4))
82

### `(value z)` where z is cookie
No answer

### Define `(value nexp)`
`(value nexp)` returns what we think is the natural value of a numbered arithmetic expression.

### How many questions does `value` ask about `nexp`
Four

### Now, let's attempt to write `value`
```
(define value
  (lambda (nexp)
    (cond
      ((atom? (car nexp)) ...)
      ((eq? (car (cdr nexp)) '+) ...)
      ((eq? (car (cdr nexp)) 'x) ...)
      (else
        ...
      )
    )
  )
)
```

### What is the natural value of an arithmetic expression that is a number?
That number

### What is the natural value of an arithmetic expression that consists of two arithmetic expressions combined by +
The sum of both arithmetic expressions if they are both numbers

### Can you think of a way to get the value of the two subexpressions in (1 + (3 x 4))
The first expression is just `1` and the second is the value of `(x 3 4)`
We can apply `value` to both expressions

### And in general?
We can do the same

### Give `value` another try.
```
(define value
  (lambda (nexp)
    (cond
      ((atom? nexp) nexp)
      ((eq? (car (cdr nexp)) '+) (+ (value (car nexp)) (value (car (cdr (cdr nexp))))))
      ((eq? (car (cdr nexp)) 'x) (x (value (car nexp)) (value (car (cdr (cdr nexp))))))
      (else
        (expt (value (car nexp)) (value (car (cdr (cdr nexp)))))
      )
    )
  )
)
```

### Can you think of a different representation of arithmetic expressions?
(+ 3 4)

### Could (3 4 +) represent 3 + 4
I guess

### Could (+ 3 4)
Yep

### Or (plus 3 4)
Also yes

### Is (+ (x 3 6) (expt 8 2)) a representation of an arithmetic expression?
Yes

### Try to write the function value for a new kind of arithmetic expression that is either:
### - a number
### - a list of the atom + followed by two arithmetic expressions,
### - a list of the atom x followed by two arithmetic expressions, or
### - a list of the atom expt followed by two arithmetic expressions.
```
(define value
  (lambda (nexp)
    (cond
      ((atom? nexp) nexp)
      ((eq? (car nexp) '+) (+ (value (car (cdr nexp))) (value (car (cdr (cdr nexp))))))
      ((eq? (car nexp) 'x) (x (value (car (cdr nexp))) (value (car (cdr (cdr nexp))))))
      (else
        (expt (value (car (cdr nexp))) (value (car (cdr (cdr nexp)))))
      )
    )
  )
)
```

### Let's write a function `1st-sub-exp `for arithmetic expressions.
```
(define 1st-sub-exp
  (lambda (aexp)
    (car (cdr aexp))
  )
)
```

### Write `2nd-sub-exp` for arithmetic expressions
```
(define 2nd-sub-exp
  (lambda (aexp)
    (car (cdr (cdr aexp)))
  )
)
```

### Finally, let's replace `(car nexp)` by `(operator nexp)`
```
(define operator
  (lambda (aexp)
    (car aexp)
  )
)
```

### Now write `value` again.
```
(define value
  (lambda (nexp)
    (cond
      ((atom? nexp) nexp)
      ((eq? (operator nexp) '+)
        (+ (value (1st-sub-exp nexp)) ((value 2nd-sub-exp nexp)))
      )
      ((eq? (operator nexp) 'x)
        (x (value (1st-sub-exp nexp)) ((value 2nd-sub-exp nexp)))
      )
      (else
        (expt (value (1st-sub-exp nexp)) ((value 2nd-sub-exp nexp)))
      )
    )
  )
)
```

### Have we seen representations before?
Yes

### For what entities have we used representations?
Lists, functions, boolean values, numbers

### Numbers are representations?
Yes. For example 4 stands for the concept four.
We chose that symbol because we are accustomed to arabic representations.

### What else could we have used?
Any symbol repeated four times or IV for example, even '(() () () ())

### Do you remember how many primitives we need for numbers?
Four => `number?`, `zero?`, `add1`, `sub1`

### Let's try another representation for numbers. How shall we represent zero now?
`()`

### How is one represented?
`(())`

### How is two represented?
`(() ())`

### Got it? What's three?
`(() () ())`

### Write a function to test for zero.
```
(define sero?
  (lambda (n)
    (null? n)
  )
)
```

### Can you write a function that is like `add1`
```
(define edd1
  (lambda (n)
    (cons '() n)
  )
)
```

### What about `sub1`
```
(define zub1
  (lambda (n)
    (cdr n)
  )
)
```

### Is this correct?
It won't work if n is zero, but thats fine (see The Law of Cdr)

### Rewrite `myadd` using this representation.
```
(define myadd
  (lambda n1 n2
    (cond
      ((sero? n2) n1)
      (else
        (edd1 (myadd n1 (zub1 n2)))
      )
    )
  )
)
```

### Has the definition of `myadd` changed?
Yes and no. It changed, but only slightly.

###  Recall `lat?``
`lat?` is a function that takes a list and checks if it is a list of atoms.

### Do you remember what the value of `(lat? ls)` is where ls is (1 2 3)
True

### What is (1 2 3) with our new numbers?
`((()) (() ()) (() () ())`

### What is `(lat? ls)` where ls is ((()) (()()) (()()()))
False

### Is that bad?
You must beware of shadows (representations).

repository: gracoes/little-schemer

repo_name: gracoes/little-schemer


text:
# SweetAlert2

Rails Gem for [SweetAlert2](https://github.com/limonte/sweetalert2)

If there are any issues, post them here. I am very active on GitHub.

## Installation

Add this line to your application's Gemfile:

    gem 'sweetalert2'

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install sweetalert2

## Usage

Just like this:

application.js:

```
//= require sweetalert2
```

application.css:

```
 *= require sweetalert2
```

## Contributing

1. Fork it ( http://github.com/KMontag42/sweetalert2-rails/fork )
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create new Pull Request

gha_license_id: MIT


text:
---
category: section-brick-onetime-token
---
Request url

For live credentials
```
 POST https://pwgateway.com/api/token
```

For test credentials

```
 POST https://api.paymentwall.com/api/brick/token
```

Code sample
```php
curl https://pwgateway.com/api/token \
-d "public_key=YOUR_PUBLIC_API_KEY" \
-d "card[number]=4000000000000002" \
-d "card[exp_month]=01" \
-d "card[exp_year]=2021" \
-d "card[cvv]=123"
```


text:
---
title: 'stream_property/2'
group: Input Output
module: sio
iso: streamproperty
predicates:
- {sig: 'stream_property/2', desc: 'retrieve streams and their properties'}
---

## FORMS

```
stream_property(Stream, Property)
```

## DESCRIPTION

`stream_property/2` is used to retrieve information on a particular stream. It may also be used to find those streams satisfying a particular property.

`Stream` may be either an input or output argument. If used as an input argument it should be bound to either a stream descriptor as returned by [`open/4`](open.html) or an alias established in a call to `open/4`. If used as an output argument, `Stream` will only be bound to stream descriptors. This predicate may be used to retrieve those streams whose handles were "lost" for some reason.

`Property` is a term which may take any of the following forms:

`file_name(F)` -- When the stream is connected to a source/sink which is a file, `F` will be the name of that file.

`stream_name(N)` -- `N` is unified with the name of the source/sink regardless of whether the stream is connected to a file or not.

`mode(M)` -- `M` is unified with the I/O mode which was specified at the time the stream was opened.

`input` -- The stream is connected to a source.

`output` -- The stream is connected to a sink. It is possible for a stream to have both input and output properties.

`alias(A)` -- If the stream has an alias, `A` will be unified with that alias.

`position(P)` -- If the stream is repositionable, `P` will be unified with the current position in the stream.

`end_of_stream(E)` -- If the stream position is located at the end of the stream, then `E` is unified with 'at' . If the stream position is past the end of stream, then `E` is unified with 'past'. Otherwise, `E` is unified with 'no'. In the current implementation of ALS Prolog, querying about the `end_of_stream` property may cause an I/O operation to result which may block.

`eof_action(A)` -- If the stream option `eof_action(Action)` was specified in the options list when the stream was opened, then `A` will be unified with this action. Otherwise, `A` will be unified with the default action appropriate for the stream.

`snr_action(A)` -- If the stream option `snr_action(Action)` was specified in the options list when the stream was opened, then `A` will be unified with this action. Otherwise, `A` will be unified with the default action appropriate for the stream.

`reposition(R)` -- If positioning is possible on this stream then `R` is unified with true; if not `R` is unified with false.

`type(T)` -- `T` will be unified with either text or binary, indicating the type of stream.

`maxdepth(D)` -- `D` will be unified with the default depth with which terms are written to.

`depth_computation(DC)` -- `DC` will be unified with the atom indicating the method of depth computation when writing out terms.

`line_length(L)` -- `L` will be unified to the default line length parameter which is used for determining where line breaks should be placed when writing terms.

## EXAMPLES

```
%% Open 'foo' for write, but "lose" the stream descriptor.
?- open(foo,write,_).

%% Use stream_property to retrieve the stream descriptor and close it.
?- stream_property(S,file_name(foo)), close(S).
S = stream_descriptor('',closed,file,foo,[noinput|output],true,
1,0,0,0,0,true,0,wt_opts(78,40000,flat),[],true,text,
eof_code,0,0)

%% Open 'foo' for read with an alias.
?- open(foo,read,_,[alias(foo_alias)]).

%% Call stream_property to find out where end-of-stream is. Note that foo was created as the empty file above.
?- stream_property(foo_alias,end_of_stream(Where)).
Where = at

%% Call stream_property again to find out about the end-of-stream.
?- stream_property(foo_alias,end_of_stream(Where)).
Where = past

%% Call stream_property to find out the name of the file associated with the alias.
?- stream_property(foo_alias,file_name(Name)).
Name = foo

%% Get all of the names attached to streams.
?- setof(N,S^stream_property(S,stream_name(N)),L).
N = N
S = S
L = ['$stderr','$stdin','$stdout',foo]
```

## SEE ALSO

- [`open/4`](open.html)
- [`close/1`](close.html)
- [`set_stream_position/2`](set_stream_position.html)
- [`at_end_of_stream/1`](at_end_of_stream.html)
- [`set_line_length/2`](set_line_length.html)
- [User Guide (Prolog I/O)](../guide/10-Prolog-I-O.html)

repository: AppliedLogicSystems/ALSProlog

gha_language: C

repo_name: AppliedLogicSystems/ALSProlog


text:
# MetaGraphs

[![Build Status][build-img]][build-url]
[![Codecov branch][codecov-img]][codecov-url]
[![](https://img.shields.io/badge/docs-latest-blue.svg)](https://juliagraphs.org/MetaGraphs.jl/dev/)

[MetaGraphs.jl](https://github.com/JuliaGraphs/MetaGraphs.jl) graphs with arbitrary metadata.

[build-img]: https://github.com/JuliaGraphs/Metagraphs.jl/workflows/CI/badge.svg?branch=master
[build-url]: https://github.com/JuliaGraphs/Metagraphs.jl/actions?query=workflow%3ACI
[codecov-img]: http://codecov.io/github/JuliaGraphs/Metagraphs.jl/coverage.svg?branch=master
[codecov-url]: http://codecov.io/github/JuliaGraphs/Metagraphs.jl?branch=master

## Documentation
Full documentation is available on the [JuliaGraphs site](https://juliagraphs.org/MetaGraphs.jl/dev/).
Documentation for methods is also available via the Julia REPL help system.

## Installation
Installation is straightforward: from the Julia `pkg` prompt,
```julia
add MetaGraphs
```

## Example Usage
```julia
julia> using Graphs, MetaGraphs

# create a standard simplegraph
julia> g = path_graph(5)
{5, 4} undirected simple Int64 graph

# create a metagraph based on the simplegraph, with optional default edgeweight
julia> mg = MetaGraph(g, 3.0)
{5, 4} undirected Int64 metagraph with Float64 weights defined by :weight (default weight 3.0)

# create a directed metagraph based on the simplegraph, with optional default edgeweight
julia> mdg = MetaDiGraph(g, 3.0)
{5, 8} directed Int64 metagraph with Float64 weights defined by :weight (default weight 3.0)

# set some properties for the graph itself
julia> set_prop!(mg, :description, "This is a metagraph.")
Dict{Symbol,Any} with 1 entry:
  :description => "This is a metagraph."

# set properties on a vertex in bulk
julia> set_props!(mg, 1, Dict(:name=>"Susan", :id => 123))
true

# set individual properties
julia> set_prop!(mg, 2, :name, "John")
true

# set a property on an edge
julia> set_prop!(mg, Edge(1, 2), :action, "knows")
true

julia> using Dates: Date

# set another property on an edge by specifying source and destination
julia> set_prop!(mg, 1, 2, :since, Date("20170501", "yyyymmdd"))
Dict{Symbol,Any} with 2 entries:
  :since   => 2017-05-01
  :action => "knows"

# get all the properties for an element
julia> props(mg, 1)
Dict{Symbol,Any} with 2 entries:
  :id   => 123
  :name => "Susan"

# get a specific property by name
julia> get_prop(mg, 2, :name)
"John"

# delete a specific property
julia> rem_prop!(mg, 1, :name)
Dict{Symbol,Any} with 1 entry:
  :id => 123

# clear all properties for vertex 2
julia> clear_props!(mg, 2)
Dict{Symbol,Any} with 0 entries

# confirm there are no properties set for vertex 2
julia> props(mg, 2)
Dict{Symbol,Any} with 0 entries

# all Graphs.jl analytics work
julia> betweenness_centrality(mg)
5-element Array{Float64,1}:
 0.0
 0.5
 0.666667
 0.5
 0.0

# using weights
julia> mg = MetaGraph(complete_graph(3))
{3, 3} undirected Int64 metagraph with Float64 weights defined by :weight (default weight 1.0)

julia> enumerate_paths(dijkstra_shortest_paths(mg, 1), 3)
2-element Array{Int64,1}:
 1
 3

julia> set_prop!(mg, 1, 2, :weight, 0.2)
true

julia> set_prop!(mg, 2, 3, :weight, 0.6)
true

julia> enumerate_paths(dijkstra_shortest_paths(mg, 1), 3)
3-element Array{Int64,1}:
 1
 2
 3

# use vertex values as indices
julia> G = MetaGraph(100)
{100, 0} undirected Int64 metagraph with Float64 weights defined by :weight (default weight 1.0)

julia> for i in 1:100
           set_prop!(G, i, :name, "node$i")
       end

julia> set_indexing_prop!(G, :name)
Set(Symbol[:name])

# nodes can now be found by the value in the index
julia> G["node4", :name]
4

# You can also find the value of an index by the vertex number (note, this behavior will dominate if index values are also integers)
julia> G[4, :name]
"node4"

julia> set_prop!(G, 3, :name, "name3") # or set_indexing_prop!(G, 3, :name, "name3")
Set(Symbol[:name])
```

gha_language: Julia

gha_license_id: NOASSERTION


text:
---
title: New resume, who dis?
date: 2023-05-24 05:00:00
categories: [projects]
tags: [personal-projects]
author: kchandan
math: true
---

New resume dropped.

I used Typst instead of LaTeX for this because it looked like an interesting language and it comes with incremental compile which is a lot nicer for me.

I tried to format the code such that there was a template file and an actual content file, but they're more interleaved than I'd like.

See the [repo at my GitHub](https://github.com/kunalchandan/resume)

and the preview
![preview](https://github.com/kunalchandan/resume/blob/main/resume-1.png?raw=true)

branch_name: refs/heads/main


text:
---
sidebar: auto
description: Use Meltano to pull data from the Fastly API and load it into Snowflake, PostgreSQL, and more
---

::: warning
This page is now deprecated and will be removed in the future.

View the current documentation on the [MeltanoHub](https://hub.meltano.com/extractors/fastly)
:::

# Fastly

The `tap-fastly` [extractor](https://hub.meltano.com/extractors/) pulls data from the [Fastly API](https://developer.fastly.com/reference/api/).

- **Repository**: <https://gitlab.com/meltano/tap-fastly>
- **Maintainer**: Meltano community
- **Maintenance status**: Active

## Getting Started

### Prerequisites

If you haven't already, follow the initial steps of the [Getting Started guide](/docs/getting-started.html):

1. [Install Meltano](/docs/getting-started.html#install-meltano)
1. [Create your Meltano project](/docs/getting-started.html#create-your-meltano-project)

### Installation and configuration

#### Using the Command Line Interface

1. Add the `tap-fastly` extractor to your project using [`meltano add`](/docs/command-line-interface.html#add):

    ```bash
    meltano add extractor tap-fastly
    ```

1. Configure the [settings](#settings) below using [`meltano config`](/docs/command-line-interface.html#config).

#### Using Meltano UI

1. Start [Meltano UI](/docs/ui.html) using [`meltano ui`](/docs/command-line-interface.html#ui):

    ```bash
    meltano ui
    ```

1. Open the Extractors interface at <http://localhost:5000/extractors>.
1. Click the "Add to project" button for "Fastly".
1. Configure the [settings](#settings) below in the "Configuration" interface that opens automatically.

### Next steps

Follow the remaining steps of the [Getting Started guide](/docs/getting-started.html):

1. [Select entities and attributes to extract](/docs/getting-started.html#select-entities-and-attributes-to-extract)
1. [Add a loader to send data to a destination](/docs/getting-started.html#add-a-loader-to-send-data-to-a-destination)
1. [Run a data integration (EL) pipeline](/docs/getting-started.html#run-a-data-integration-el-pipeline)

If you run into any issues, [learn how to get help](/docs/getting-help.html).

## Settings

`tap-fastly` requires the [configuration](/docs/configuration.html) of the following settings:

- [API Token](#api-token)
- [Start Date](#start-date)

These and other supported settings are documented below.
To quickly find the setting you're looking for, use the Table of Contents in the sidebar.

#### Minimal configuration

A minimal configuration of `tap-fastly` in your [`meltano.yml` project file](/docs/project.html#meltano-yml-project-file) will look like this:

```yml{5-6}
plugins:
  extractors:
  - name: tap-fastly
    variant: meltano
    config:
      start_date: '2020-10-01T00:00:00Z'
```

Sensitive values are most appropriately stored in [the environment](/docs/configuration.html#configuring-settings) or your project's [`.env` file](/docs/project.html#env):

```bash
export TAP_FASTLY_API_TOKEN=my_api_token
```

### API Token

- Name: `api_token`
- [Environment variable](/docs/configuration.html#configuring-settings): `TAP_FASTLY_API_TOKEN`

API token

#### How to use

Manage this setting using [Meltano UI](#using-meltano-ui), [`meltano config`](/docs/command-line-interface.html#config), or an [environment variable](/docs/configuration.html#configuring-settings):

```bash
meltano config tap-fastly set api_token <token>

export TAP_FASTLY_API_TOKEN=<token>
```

### Start Date

- Name: `start_date`
- [Environment variable](/docs/configuration.html#configuring-settings): `TAP_FASTLY_START_DATE`

This property determines how much historical data will be extracted.

Please be aware that the larger the time period and amount of data, the longer the initial extraction can be expected to take.

#### How to use

Manage this setting using [Meltano UI](#using-meltano-ui), [`meltano config`](/docs/command-line-interface.html#config), or an [environment variable](/docs/configuration.html#configuring-settings):

```bash
meltano config tap-fastly set start_date YYYY-MM-DDTHH:MM:SSZ

export TAP_FASTLY_START_DATE=YYYY-MM-DDTHH:MM:SSZ

# For example:
meltano config tap-fastly set start_date 2020-10-01T00:00:00Z

export TAP_FASTLY_START_DATE=2020-10-01T00:00:00Z
```

repository: forestlzj/meltano

repo_name: forestlzj/meltano


text:
---
layout: default
---

# 1996-02-19 - Re: True random numbers

## Header Data

From<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 2d727899782f97965902ebc5696e8de54058ee8d91506deabf10a3b6f1aee52d

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1996-02-19 19:07:43 UTC

Raw Date: Tue, 20 Feb 1996 03:07:43 +0800

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>Date: Tue, 20 Feb 1996 03:07:43 +0800
To<EMAIL_ADDRESS>Subject: Re: True random numbers
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Tim May writes:
>4. I'd avoid altogether phrases such as "generates random numbers," unless
>your method uses radioactive decay or Johnson noise measurements, for
>example, and maybe not even then.

Persi Diaconis gave a talk here last week on pseudorandom generation,
during which he was asked by people didn't use hardware RNGs.  He said
that he wasn't aware of any that passed the standard battery of
statistical tests.

(He also mentioned that nobody had thoroughly tested the
complexity-theoretic generators such as Blum-Micali, and got into a
rather vigorous discussion with a professor who argued that testing
was superfluous.  Diaconis: "You theorists always take that tone!")

--
. Eli Brandt                                        usual disclaimers .
<EMAIL_ADDRESS>                                PGP key on request .
. arrest me:                       violation of 18 U.S.C. 1462: "fuck".

{% endraw %}
```

## Thread

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

+ Return to "[eli+@GS160.SP.CS.CMU.EDU](/authors/eli_at_gs160_sp_cs_cmu_edu)"

+ _Unknown thread root_
  + 1996-02-19 (Tue, 20 Feb 1996 03:07:43 +0800) - Re: True random numbers -<EMAIL_ADDRESS>


text:
---
layout: post
title: "Marid"
date: 2017-09-10
tags: [large, elemental, cr11, monster-manual]
---

**Large elemental, chaotic neutral**

**Armor Class** 17 (natural armor)

**Hit Points** 229 (17d10+136)

**Speed** 30 ft., fly 60 ft., swim 90 ft.

|   STR   |   DEX   |   CON   |   INT   |   WIS   |   CHA   |
|:-----:|:-----:|:-----:|:-----:|:-----:|:-----:|
| 22 (+6) | 12 (+1) | 26 (+8) | 18 (+4) | 17 (+3) | 18 (+4) |

**Saving Throws** Dex +5, Wis +7, Cha +8

**Damage Resistances** acid, cold, lightning

**Senses** blindsight 30 ft., darkvision 120 ft.

**Languages** Aquan

**Challenge** 11 (7,200 XP)

***Amphibious.*** The marid can breathe air and water.

***Elemental Demise.*** If the marid dies, its body disintegrates into a burst of water and foam, leaving behind only equipment the marid was wearing or carrying.

***Innate Spellcasting.*** The marid's innate spellcasting ability is Charisma (spell save DC 16, +8 to hit with spell attacks). It can innately cast the following spells, requiring no material components:

At will: create or destroy water, detect evil and good, detect magic, fog cloud, purify food and drink

3/day each: tongues, water breathing, water walk

1/day each: conjure elemental (water elemental only), control water, gaseous form, invisibility, plane shift

***Variant: Genie Powers.*** Genies have a variety of magical capabilities, including spells. A few have even greater powers that allow them to alter their appearance or the nature of reality.

Disguises.

Some genies can veil themselves in illusion to pass as other similarly shaped creatures. Such genies can innately cast the disguise self spell at will, often with a longer duration than is normal for that spell. Mightier genies can cast the true polymorph spell one to three times per day, possibly with a longer duration than normal. Such genies can change only their own shape, but a rare few can use the spell on other creatures and objects as well.

Wishes.

The genie power to grant wishes is legendary among mortals. Only the most potent genies, such as those among the nobility, can do so. A particular genie that has this power can grant one to three wishes to a creature that isn't a genie. Once a genie has granted its limit of wishes, it can't grant wishes again for some amount of time (usually 1 year). and cosmic law dictates that the same genie can expend its limit of wishes on a specific creature only once in that creature's existence.

To be granted a wish, a creature within 60 feet of the genie states a desired effect to it. The genie can then cast the wish spell on the creature's behalf to bring about the effect. Depending on the genie's nature, the genie might try to pervert the intent of the wish by exploiting the wish's poor wording. The perversion of the wording is usually crafted to be to the genie's benefit.

**Actions**

***Multiattack.*** The marid makes two trident attacks.

***Trident.*** Melee or Ranged Weapon Attack: +10 to hit, reach 5 ft. or range 20/60 ft., one target. Hit: 13 (2d6 + 6) piercing damage, or 15 (2d8 + 6) piercing damage if used with two hands to make a melee attack.

***Water Jet.*** The marid magically shoots water in a 60-foot line that is 5 feet wide. Each creature in that line must make a DC 16 Dexterity saving throw. On a failure, a target takes 21 (6d6) bludgeoning damage and, if it is Huge or smaller, is pushed up to 20 feet away from the marid and knocked prone. On a success, a target takes half the bludgeoning damage, but is neither pushed nor knocked prone.

extension: markdown

gha_language: Vue


text:
---
hrs_structure:
  division: '5'
  volume: '14'
  title: '37'
  chapter: '708'
  section: 708-824
type: hrs_section
tags:
  - Crime
  - Criminal Proceeding
menu:
  hrs:
    identifier: HRS_0708-0824
    parent: HRS0708
    name: 708-824 Failure to control widely dangerous means
weight: 22125
title: Failure to control widely dangerous means
full_title: 708-824 Failure to control widely dangerous means
---
**§708-824 Failure to control widely dangerous means.** (1) A person commits the offense of failure to control widely dangerous means if, knowing that widely dangerous means are endangering life or property, the person negligently fails to take measures to prevent or mitigate the danger and:

(a) The person knows that the person is under an official, contractual, or other legal duty to take measures to prevent, control, or mitigate the danger; or

(b) The means were employed by the person or with the person's assent, or on premises in the person's custody or control.

(2) Failure to control widely dangerous means is a misdemeanor. [L 1972, c 9, pt of §1; gen ch 1993]

COMMENTARY ON §708-824

This section imposes misdemeanor liability upon a person for the negligent failure to prevent or mitigate danger resulting from the use of widely dangerous means where either (a) the actor is under some legal duty to do so, or (b) the actor is actually or constructively responsible for employing such means. This offense combines the Model Penal Code's offenses of "Failure to Control or Report a Dangerous Fire" and "Failure to Prevent Catastrophe."[1] The underlying premise is that a citizen's criminal liability for potential widespread destruction arises from the citizen's tortious or contractual liability with regard to the potential harm.

Hawaii previously had no statute dealing generally with the problems of catastrophe and the mitigation of the risk thereof but rather dealt separately with various substantive acts which represented a general public danger. The only general heading under which such offenses were grouped is "common nuisance," which included such widely dangerous aspects as spreading disease, making and storing gunpowder, blasting with explosives, and keeping dangerous animals.[2] In a similar vein, however, Hawaii provided a misdemeanor sanction for the failure of any able-bodied person to help combat a fire.[3] In simplifying and combining the above-mentioned sections of the Model Penal Code, this Code fills an apparently neglected area of Hawaii law.

**__________**

**§708-824** **Commentary:**

1\. M.P.C. §§220.1(3) and 220.2(3), respectively.

2\. H.R.S. §727-1.

3\. Id. §185-8.

repository: SamMade/BlueAndKrabby

repo_name: SamMade/BlueAndKrabby


text:
# BonusQuestion
This respiratory is for the bonus question.
It has 2 classes;
- Bonus Question
- Question

Author : Neslihan Salimoglu
Address of the remote repository : https://github.com/neslihansalimoglu/BonusQuestion

repository: neslihansalimoglu/BonusQuestion

repo_name: neslihansalimoglu/BonusQuestion


text:
# Hashtables

[<--- Back to Table of Contents](../../../README.md)

* a data structure that utilizes key value pairs

* every Node or Bucket has both a key, and a value

* basic idea of a hashtable is the ability to store the key and quickly retrieve the value through a hash

* hash is the ability to encode the key that will eventually map to a specific location

* in the data structure, we can directly retrieve the value

## Challenge

Implement a Hashtable with the following methods with add, get, contains and hash methods.

## Approach & Efficiency

My implementation uses linked lists as buckets. Each index contains a bucket. In each index of the array of the hashtable Each index is a bucket. An index could potentially contain multiple key/value pairs if a collision occurs.

* O(1) time complexity for lookups

## API

### .add(key, value)

* takes in both the key and value, hashes the key, and adds the key and value pair to the table, handling collisions as needed

### .get(key)

* takes in the key and returns the value from the table or an array of values if the key has multiple pairs

### .contains(key)

* takes in the key and returns a boolean, indicating if the key exists in the table already

### .hash(key)

* takes in an arbitrary key and returns an index in the collection

## Javascript Implementation && Testing

[Implementation](./hashtable.js)

[Tests](./__tests__/hashtable.test.js)


text:
Simple node module for choosing how much detail to log to the console. Syntax inspired by logit.

## Usage

```js
var LogStuff = require('log-stuff');
var log = new LogStuff('WARN'); //set your log level here

//these are all the 6 levels
log.error('an error message');
log.warn('a warning message');
log.info('an information message');
log.debug('some debug details');
log.finer('some finer debug details');
log.finest('the finest debug details');
```

...would output this on stdout:

```
ERROR: an error message
WARN: a warning message
```

There's also something you can use to show a progress bar or counter. It's one line, always kept below the other logs (uses single-line-log) and gets displayed in all logging levels.

```js
log.error('an error');
log.progress('1 call');
log.warn('a warning');
log.progress('2 call');
```

would output:

```
ERROR: an error
WARN: a warning
2 call
```

repository: adanilev/log-stuff

repo_name: adanilev/log-stuff


text:
# photocopy

A weird little iteration library.

`npm install photocopy`

After the readme, check out the usage examples in the [x folder](x)!

## copy = photocopy(original[, transform[, seed[, collect]]])

`original` is the collection to iterate over.

`transform` is a function that takes the next step in a process, and
returns a reducing function. That reducing function is called
once per step, and calls the next step in the process 0 or more times.
Defaults to the identity transform.

`seed` is the value to reduce into.  By default we try to build a seed
the same type as original with `new original.constructor`, if that
doesn't exist we use a standard object.

`collect` is the final step in the process, which puts new values into
the accumulated value. Defaults to trying to match something compatible
with the seed value (even if seed itself was defaulted). Falls back to
generically adding properties to the seed.

## transforms

### pc.map(fn)

Takes a function that gets (value, key), and returns the new value.

### pc.keyMap(fn)

Takes a function that gets (value, key), and returns the new key.

### pc.filter(fn)

Takes a function that gets (value, key), and returns truthy to keep, falsy
to skip.

### pc.take(num)

Take the first `num` items.

### pc.skip(num)

Skip the first `num` items.

### pc.cat

Unwraps collections into their individual values/keys.

### pc.steamroll

Recursively unwraps nested collections into their leaf node values/keys.

### pc.identity

Passes things through unchanged.

## Utilities

### pc.byKey

A collecting function that creates arrays of values, stored
by key on an object.

### comp(fn0[, fn1[,...fnN]]) // takes any number of functions

Compose transforms together, to be run in order left to right on
each item.

### simple(fn)

The easiest way to make a simple transform creator. Takes a function
that will be called with (f, next, acc, val, key), and returns a
function that should be called with the 'f' value. Should apply f and
next in various ways to acc, val, and key.

### done(acc, value, key)

Test to see if acc is reduced, or value and key are both undefined.
Useful to know if the transducing process is done.

### reduced(final)

When you want to fast track processing to the end, return reduced(final)
from any step in the process, and final will be returned as the final
product. No more steps are iterated. Do not pass go, do not collect
$200.

## example

```javascript

var pc = require('photocopy')

// shallow copy
var copyOfA = pc({ a: 1, b: 2 })

// map/forEach
var squaredArray = pc([ 3, 4, 5 ], pc.map(function (val) { return val * val }))

// array-like to array
var args
;(function () {
  args = pc(arguments, pc.identity, [])
})(1, 2, 3)

// transformed copy

function Dog () { this.says = 'bark'; this.weight = 45; this.name = 'foo' }

var intenseDog = pc(new Dog(), pc.map(transform))
intenseDog instanceof Dog // true

function transform (val, key) {
  if (key === 'name') return 'bar'
  return val + val
}

console.log(copyOfA, squaredArray, args, intenseDog)

```

## History

This library evolved from only being able to run a map on an object, to
applying arbitrary transformations to any collection. It is largely
inspired by transducers, but doesn't interoperate with other JS transducer
libraries. The biggest reason is that photocopy supports keys as an extra
argument, instead of wrapping some collections in [ key, value ] arrays. It
also works as variable argument functions, instead of making the initialized
transducers objects with weird private properties. Does not support arity
0 to get a seed value from a step function.

Also the top level API feels a lot more comfortable to me, and we don't provide
a lot of uncommonly used transforms, instead leaving you the fun of
implementing them for yourself.

## License: ISC

Copyright 2016 Nick Niemeir<EMAIL_ADDRESS>

license: ISC

repository: nrn/photocopy

gha_language: JavaScript

repo_name: nrn/photocopy


text:
---
title: Managing Virtual Machines
---

# Chapter 2: Managing Virtual Machines

You can perform common virtual machine management tasks in the virtual machines pane:

* Start up a virtual machine by clicking the **Run** icon (![](/images/intro-vm-portal/Run.png)). It is available when the virtual machine is paused, stopped, or powered off.

* Temporarily stop a virtual machine by clicking the **Suspend** icon (![](/images/intro-vm-portal/Suspend.png)). It is available when the virtual machine is running.

* Stop a virtual machine by clicking the **Shutdown** icon (![](/images/intro-vm-portal/Shutdown.png)). It is available when the virtual machine is running.

* Restart a virtual machine by clicking the **Reboot** icon (![](/images/intro-vm-portal/Reboot.png)).  It is available when the virtual machine is running.

* Access the console of a virtual machine by clicking the **Console** icon (![](/images/intro-vm-portal/Console.png)). It is available when the virtual machine is running.

* Edit a virtual machine by clicking the **Edit** icon (![](/images/intro-vm-portal/Edit_VM.png)).

## Viewing virtual machine details

**Viewing a virtual machine's details**

Click the virtual machine's name in the virtual machines pane to go to the details view. The following details display:

* **State** - For example, `Up`, `Down`, `Paused`, `Suspended`

* **Description** (optional)

* **Cluster**

* **Template**

* **Operating System**

* **Optimized for** - `Desktop`/`Server`/`High Performance`

* **Defined Memory**

* **CPUs**

* **Address** - Virtual machine's FQDN. The guest agent must be installed on the virtual machine to retrieve this value.

* **CD**

* **Console** - See the "Changing console settings" section for more information about console options.

* **Disks** - Clicking the **Edit** icon displays the **Delete** and **New** buttons, for deleting the current disk and creating a new disk.

* **Network interfaces** - Clicking the **Edit** icon displays the **Delete** and **New** buttons, for deleting the current network interface and creating a new network interface.

* **Boot Menu** status - `On`/`Off`

* **Cloud-Init** status - `On`/`Off`. To change the **Boot Menu** or **Cloud-Init** status, see the "Editing virtual machines".

To go directly to the details view of other virtual machines, click the collapsible arrow on the left side of the details pane to open a list of available virtual machines. You can click each machine name to view its details.

## Editing virtual machines

    **Note:** Your user role must have permission to edit a virtual machine.

You can edit a virtual machine's disk, network interfaces, and console settings in the virtual machine's details view. See the "Viewing virtual machine details" section.

**Editing a virtual machine**

1. In the virtual machines pane, click the **Edit** icon (![](/images/intro-vm-portal/Edit_VM.png)) of the virtual machine that you want to edit. The following fields appear:

   * **Name** of the virtual machine. The virtual machine name may contain only upper- or lower-case letters, numbers, underscores, hyphens, or periods. Special characters and spaces are not permitted.

   * **Description** (optional)

   * **Cluster**

   * **Template**

   * **Operating System**

   * **Defined Memory**

   * **CPUs**

   * **CD**

   * **Boot menu** - When this is set to `ON`, the **Boot** menu appears in the console, enabling you to select a bootable device.

   * **Cloud-Init** - The `cloud-init` tool allows you to automate the deployment of virtual machines. When this is set to `ON`, the **Hostname** and **SSH Authorized Keys** fields display.

2. Click **Update VM**.

**Changing a virtual machine's icon**

1. Click the **Edit** icon under the virtual machine's icon.

2. Browse to your image and click **Open**. The maximum permitted size is 150 x 120 pixels.

To restore the default icon, click the circular arrow.

## Creating virtual machines

**Creating a virtual machine**

1. Click the **Add New VM** button in the toolbar.

2. Set the following fields:

   * **Name** of the virtual machine. The virtual machine name may contain only upper- or lower-case letters, numbers, underscores (`_`), hyphens (`-`), or periods (`.`). Special characters and spaces are not permitted.

   * **Description** (optional)

   * **Cluster**

   * **Template**

   * **Operating System**

   * **Defined Memory**

   * **CPUs**

   * **CD**

3. Click **Create VM**.

## Connecting to virtual machines

**Connecting to a virtual machine**

1. In the virtual machines pane, click the **Run** icon to start a virtual machine.

2. Click the **Console** icon to connect to the virtual machine.

3. You will be asked to download a **.vv** file.

4. Open the file with **remote-viewer**. A console window displays.

   You can now use the virtual machine in the same way that you would use a physical desktop.

   # Changing console settings

   **Note:** The `Console` settings may be changed by any user who has permission to view the virtual machine. The changes are stored locally in the browser, not on the server.

   **Changing console settings**

   1. In the virtual machines pane, click the virtual machine name to go to the details view.

   2. Click the **Console** settings icon (![](/images/intro-vm-portal/Edit_blue.png)) to access the following options:

      * **Connect automatically**: Enables you to connect automatically if only one virtual machine is running.

      * **Fullscreen**: Opens the virtual machine console in full screen automatically when you connect to the virtual machine. Press `SHIFT + F11` to toggle full screen mode on or off.

      * **Use Ctrl+Alt+Del**: Maps the `Ctrl+Alt+End` key combination to `Ctrl+Alt+Del` inside the virtual machine.

      * **Smartcard enabled**: Allows you to pass the smartcard from your client machine to the virtual machine.

**Prev:** [Chapter 1: Accessing the VM Portal](../What_is_the_VM_Portal)

[Adapted from RHV 4.2 documentation - CC-BY-SA](https://access.redhat.com/documentation/en-us/red_hat_virtualization/4.2/html/introduction_to_the_vm_portal/chap-managing_virtual_machines)

repository: sgratch/ovirt-site

repo_name: sgratch/ovirt-site


text:
# Vortex Panel Method
Calculating Vortex Strengths of Each Panel for the Vortex Panel Method with the Example of a Circular Cylinder

# Language and Environment
Written in Fortran90 compatible with the Linux GNU gfortran compiler. [LAPACK](https://github.com/Reference-LAPACK/lapack) is required for matrix inversion

# Sample Geometry
![Sample Geometry](https://drive.google.com/uc?export=view&id=1s_A3oSA1bRufd-UQqJIdCOeXWa3vUilE)

# Input (input.in)
  - NPTS: # of total node points
  - FRANG: Angle of attack of the free stream flow
  - ISSYM: Symmetric flow (if 1) or asymmetric flow where the stagnation point occurs at θ = -150˚ (if 0)
  - X, Y: Nodes for vortex panels. Starts from the stangation point, indexed clockwise


text:
# NetworkHelper
Network Helper for Android.

## Http Downloader
A download helper that can support Breakpoint resume and Multi-tasking download.

### Download directly

```java
    /**
     * Save urlToDownload to file as outputPath directly.
     * Make sure to call this method in a worker thread for avoid block the UI thread.
     * @param urlToDownload: the HTTP URL to be downloaded.
     * @param outputPath: Path to save the downloaded file. If the outputPath
     *                  just is a directory(not contains file name) then
     *                  the downloader will guess a name by URL.
     * @return ERR_OK if download successfully, else return a error code.
     **/
    public static int downloadFile(String urlToDownload, String outputPath);

    /**
     * Save urlToDownload to file as outputPath directly.
     * Make sure to call this method in a worker thread for avoid block the UI thread.
     * @param urlToDownload the HTTP URL to be downloaded.
     * @param outputPath Path to save the downloaded file. If the outputPath
     *                  just is a directory(not contains file name) then
     *                  the downloader will guess a name by URL.
     * @param listener A listener for receive notify sent by downloader.
     * @return ERR_OK if download successfully, else return a error code.
     **/
    public static int downloadFile(String urlToDownload, String outputPath,
                            DownloadListener listener);

```

### Parallel download by service

```java
    /**
     * Start download url to local file as outputPath via a Service.
     * Download task will be execute in a worker thread.
     * @param url the HTTP URL to be downloaded.
     * @param outputPath Path to save the downloaded file. If the outputPath
     *                  just is a directory(not contains file name) then
     *                  the downloader will guess a name by URL.
     * @param listener A listener for receive notify sent by downloader.
     * @return ERR_OK if download successfully, else return a error code.
     **/
    public void startDownloadInParallel(String url, String outputPath,
                                         DownloadListener listener);

    /**
     * Stop a download task in DownloadService.
     * @param url the HTTP URL to be downloaded.
     * @param outputPath Path to save the downloaded file. If the outputPath
     *                  just is a directory(not contains file name) then
     *                  the downloader will guess a name by URL.
     * @param listener A listener for receive notify sent by downloader.
     * @return ERR_OK if download successfully, else return a error code.
     **/
    public void stopDownloadInParallel(String url, String outputPath,
                                        DownloadListener listener);

```

### Add Service to AndroidManifest.xml

```
        <service android:name="com.coopox.network.http.DownloadService" />
        <service android:name="com.coopox.network.http.DownloadIntentService" />

```

repository: lokii/NetworkHelper

gha_language: Java

repo_name: lokii/NetworkHelper


text:
---
hrs_structure:
  division: '2'
  volume: '11'
  title: '27'
  chapter: '490'
  section: '490:9-338'
type: hrs_section
tags:
  - Business
menu:
  hrs:
    identifier: HRS_0490-0009-0338
    parent: HRS0490
    name: '490:9-338 Priority of security interest or agricultural lien'
weight: 78645
title: Priority of security interest or agricultural lien
full_title: '490:9-338 Priority of security interest or agricultural lien'
---
**§490:9-338 Priority of security interest or agricultural lien perfected by filed financing statement providing certain incorrect information.** If a security interest or agricultural lien is perfected by a filed financing statement providing information described in section 490:9-516(b)(5) which is incorrect at the time the financing statement is filed:

(1) The security interest or agricultural lien is subordinate to a conflicting perfected security interest in the collateral to the extent that the holder of the conflicting security interest gives value in reasonable reliance upon the incorrect information; and

(2) A purchaser, other than a secured party, of the collateral takes free of the security interest or agricultural lien to the extent that, in reasonable reliance upon the incorrect information, the purchaser gives value and, in the case of tangible chattel paper, tangible documents, goods, instruments, or a security certificate, receives delivery of the collateral. [L 2000, c 241, pt of §1; am L 2004, c 163, §32]


text:
Twig GitHub Gist Sculpin Bundle
===============================

A [Sculpin](http://getsculpin.com) bundle to provide the ability to
embed [GitHub](http://github.com) [Gist](http://gist.github.com)
snippets into [Twig](http://twig.sensiolabs.org/) formatted pages.

Deprecated
==========

This project has been deprecated in favor of a generic Symfony2 bundle
[dflydev/github-gist-twig-bundle](https://github.com/dflydev/dflydev-github-gist-twig-bundle).

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

 * PHP: >=5.3.2

Usage
-----

Add the following to `composer.json` for the Sculpin site:

```json
{
    "require": {
        "dflydev/twig-github-gist-sculpin-bundle": "1.*"
    }
}
```

Run `sculpin composer:update` to download the bundle and its
dependencies.

Add the following to `sculpin.yml` or whichever configuration
is most appropriate for the Sculpin site:

```yaml
bundles:
  - dflydev\sculpin\bundle\twigGitHubGistBundle\TwigGitHubGistBundle
```

License
-------

MIT, see LICENSE.

Community
---------

Want to get involved? Here are a few ways:

* Find us in the [#sculpin](irc://irc.freenode.org/sculpin) IRC
  channel on irc.freenode.org.
* Join the [Sculpin Users](http://groups.google.com/group/sculpin-users)
  mailing list.
* Mention [@getsculpin](http://twitter.com/getsculpin) on Twitter.