text:
[//000000001]: # (struct::stack \- Tcl Data Structures)
[//000000002]: # (Generated from file 'stack\.man' by tcllib/doctools with format 'markdown')
[//000000003]: # (struct::stack\(n\) 1\.5\.3 tcllib "Tcl Data Structures")

 [ Main Table Of Contents | Table Of Contents | Keyword Index | Categories | Modules | Applications ]

# NAME

struct::stack \- Create and manipulate stack objects

# Table Of Contents

  - [Table Of Contents](#toc)

  - [Synopsis](#synopsis)

  - [Description](#section1)

  - [Bugs, Ideas, Feedback](#section2)

  - [Keywords](#keywords)

  - [Category](#category)

# SYNOPSIS

package require Tcl 8\.4
package require struct::stack ?1\.5\.3?

[*stackName* __option__ ?*arg arg \.\.\.*?](#1)
[*stackName* __clear__](#2)
[*stackName* __destroy__](#3)
[*stackName* __get__](#4)
[*stackName* __getr__](#5)
[*stackName* __peek__ ?*count*?](#6)
[*stackName* __peekr__ ?*count*?](#7)
[*stackName* __trim__ ?*newsize*?](#8)
[*stackName* __trim\*__ ?*newsize*?](#9)
[*stackName* __pop__ ?*count*?](#10)
[*stackName* __push__ *item* ?*item\.\.\.*?](#11)
[*stackName* __size__](#12)

# DESCRIPTION

The __::struct__ namespace contains a commands for processing finite stacks\.

It exports a single command, __::struct::stack__\. All functionality provided
here can be reached through a subcommand of this command\.

*Note:* As of version 1\.3\.3 of this package a critcl based C implementation is
available\. This implementation however requires Tcl 8\.4 to run\.

The __::struct::stack__ command creates a new stack object with an
associated global Tcl command whose name is *stackName*\. This command may be
used to invoke various operations on the stack\. It has the following general
form:

  - *stackName* __option__ ?*arg arg \.\.\.*?

    *Option* and the *arg*s determine the exact behavior of the command\. The
    following commands are possible for stack objects:

  - *stackName* __clear__

    Remove all items from the stack\.

  - *stackName* __destroy__

    Destroy the stack, including its storage space and associated command\.

  - *stackName* __get__

    Returns the whole contents of the stack as a list, without removing them
    from the stack\.

  - *stackName* __getr__

    A variant of __get__, which returns the contents in reversed order\.

  - *stackName* __peek__ ?*count*?

    Return the top *count* items of the stack, without removing them from the
    stack\. If *count* is not specified, it defaults to 1\. If *count* is 1,
    the result is a simple string; otherwise, it is a list\. If specified,
    *count* must be greater than or equal to 1\. If there are not enoughs items
    on the stack to fulfull the request, this command will throw an error\.

  - *stackName* __peekr__ ?*count*?

    A variant of __peek__, which returns the items in reversed order\.

  - *stackName* __trim__ ?*newsize*?

    Shrinks the stack to contain at most *newsize* elements and returns a list
    containing the elements which were removed\. Nothing is done if the stack is
    already at the specified size, or smaller\. In that case the result is the
    empty list\.

  - *stackName* __trim\*__ ?*newsize*?

    A variant of __trim__ which performs the shrinking, but does not return
    the removed elements\.

  - *stackName* __pop__ ?*count*?

    Return the top *count* items of the stack, and remove them from the stack\.
    If *count* is not specified, it defaults to 1\. If *count* is 1, the
    result is a simple string; otherwise, it is a list\. If specified, *count*
    must be greater than or equal to 1\. If there are not enoughs items on the
    stack to fulfull the request, this command will throw an error\.

  - *stackName* __push__ *item* ?*item\.\.\.*?

    Push the *item* or items specified onto the stack\. If more than one
    *item* is given, they will be pushed in the order they are listed\.

  - *stackName* __size__

    Return the number of items on the stack\.

# Bugs, Ideas, Feedback

This document, and the package it describes, will undoubtedly contain bugs and
other problems\. Please report such in the category *struct :: stack* of the
[Tcllib Trackers](http://core\.tcl\.tk/tcllib/reportlist)\. Please also report
any ideas for enhancements you may have for either package and/or documentation\.

When proposing code changes, please provide *unified diffs*, i\.e the output of
__diff \-u__\.

Note further that *attachments* are strongly preferred over inlined patches\.
Attachments can be made by going to the __Edit__ form of the ticket
immediately after its creation, and then using the left\-most button in the
secondary navigation bar\.

# KEYWORDS

[graph](\.\./\.\./\.\./\.\./index\.md\#graph),
[matrix](\.\./\.\./\.\./\.\./index\.md\#matrix),
[queue](\.\./\.\./\.\./\.\./index\.md\#queue), [tree](\.\./\.\./\.\./\.\./index\.md\#tree)

# CATEGORY

Data structures

repository: markemer/macports-base

gha_language: Tcl

repo_name: markemer/macports-base


text:
[# birthName]
David Warren Brubeck

[# born]
December 6, 1920 in Concord, CA

[# genre]
Jazz

[# yearsActive]
'40s, '50s, '60s, '70s, '80s, '90s, '00s, '10s

[# biography]
### Dave Brubeck
In the 1950s and '60s, few American jazz artists were as influential, and fewer still were as popular, as Dave Brubeck. At a time when the cooler sounds of West Coast jazz began to dominate the public face of the music, Brubeck proved there was an audience for the style far beyond the confines of the in-crowd, and with his emphasis on unusual time signatures and adventurous tonalities, Brubeck showed that ambitious and challenging music could still be accessible. And as rock & roll began to dominate the landscape of popular music at the dawn of the '60s, Brubeck enjoyed some of his greatest commercial and critical success, expanding the audience for jazz and making it hip with young adults and college students.

[# benefits]
Few American jazz artists were as influential, and fewer still were as popular, as Dave Brubeck

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# LiveResource Test Server

This is a simple server written in Node.js that implements the various transport combinations of the LiveResource protocol. There is a public instance available at [http://test.liveresource.org/](http://test.liveresource.org/).

The server exposes two resources:

* `/test`: value contains the current time as a unix timestamp. It changes every 3 seconds.
* `/test2`: like `/test`, but an hour ahead. It changes every 10 seconds.

Example request:
```http
GET /test HTTP/1.1
Host: test.liveresource.org
```

Example response:
```http
HTTP/1.1 200 OK
ETag: "1456905833"
X-Poll-Interval: 10
Link: </test?after=1456905833>; rel=changes
Link: </test>; rel=value-wait
Link: </test?after=1456905833>; rel=changes-wait
Link: </test>; rel=value-stream
Link: </test?changes>; rel=changes-stream
Link: </test?hints>; rel=hint-stream
Link: </multi>; rel=multiplex-wait
Link: </ws>; rel=multiplex-socket
Content-Type: application/json

{"time":<PHONE_NUMBER>}
```

Query parameters can be used to control which features are advertised and how the server should behave:

* `types={types}`: Comma-separated list of Link rel types to support, e.g. `changes,value-wait` (default all).
* `no_poll_header`: If present, don't set `X-Poll-Interval`.
* `no_previous`: If present, don't provide `Previous-ETag` in stream/socket pushes.
* `no_share_multiplex`: If present, don't offer the same `multiplex-wait` or `multiplex-socket` links across different resources. Intead offer unique endpoints per-resource.
* `reliable`: If present, advertise reliable versions of transports.
* `timeout={x}`: Tell the server to close the connection after `x` seconds. Use to simulate disconnects.

The `/test` resource supports listening for changes. It uses a custom format for changes that looks like this:

```json
{"time:change": "+10"}
```

The above changes payload would mean the time has increased by 10 seconds since the last update. The reason for the odd custom format here is to demonstrate that LiveResource is agnostic to the format.

For unreliable transports (the default), the server deliberately skips pushing data sometimes, to simulate lossy delivery.

## Limiting available transports

The `types` parameter can be used to tell the server which transports to offer.

Example request:
```http
HEAD /test?types=value-wait HTTP/1.1
Host: test.liveresource.org
```

Example response:
```http
HTTP/1.1 200 OK
ETag: "1456905833"
X-Poll-Interval: 10
Link: </test>; rel=value-wait
Content-Type: application/json
```

## Transport examples

### Plain-polling

The resources on the test server support plain polling. Obviously this is the case for the resource value, but polling of changes is also possible with the `changes` link.

The server sends the `X-Poll-Interval` response header in order to control the rate the client polls. If you want to test client behavior in the absence of this header, set the `no_poll_header` query parameter.

Plain-poll for value:
```http
GET /test HTTP/1.1
Host: test.liveresource.org
```

Response:
```http
HTTP/1.1 200 OK
ETag: "1456905833"
X-Poll-Interval: 10
Link: </test?after=1456905833>; rel=changes
Content-Type: application/json

{"time":<PHONE_NUMBER>}
```

Plain-poll for changes:
```http
GET /test?after=1456905833 HTTP/1.1
Host: test.liveresource.org
```

Response:
```http
HTTP/1.1 200 OK
X-Poll-Interval: 10
Link: </test?after=1456905843>; rel=changes
Content-Type: application/json

{"time:change": "+10"}
```

Plain-poll without server-specified poll interval:
```http
GET /test?no_poll_interval HTTP/1.1
Host: test.liveresource.org
```

Response:
```http
HTTP/1.1 200 OK
ETag: "1456905833"
Link: </test?after=1456905833>; rel=changes
Content-Type: application/json

{"time":<PHONE_NUMBER>}
```

### Long-polling

The resources on the test server support long-polling.

Long-poll for value:
```http
GET /test HTTP/1.1
Host: test.liveresource.org
If-None-Match: "1456905833"
Wait: 55
```

Response if resource unchanged after wait time expires:
```http
HTTP/1.1 304 Not Modified
ETag: "1456905833"
Content-Type: application/json
```

Response if resource changes while waiting:
```http
HTTP/1.1 200 OK
ETag: "1456905843"
Content-Type: application/json

{"time":<PHONE_NUMBER>}
```

Long-poll for changes:
```http
GET /test?after=1456905833 HTTP/1.1
Host: test.liveresource.org
Wait: 55
```

Response if resource unchanged after wait time expires:
```http
HTTP/1.1 200 OK
Content-Type: application/json

{"time:change": "+0"}
```

Response if resource changes while waiting:
```http
HTTP/1.1 200 OK
Link: </test?after=1456905843>; rel=changes-wait
Content-Type: application/json

{"time:change": "+10"}
```

### Multiplex long-polling

It is possible to long-poll multiple resources in a single request. There are 3 `multiplex-wait` endpoints:

* `/multi`: supports requests for `/test` or `/test2`.
* `/test/multi`: supports requests for `/test` only.
* `/test2/multi`: supports requests for `/test2` only.

The `no_share_multiplex` option can be used to tell the server to not advertise the same multiplex link for different resources. This can be useful to force clients to use different multiplex endpoints at the same time, for testing.

Long-poll for value of one resource and changes of another:
```http
GET /multi HTTP/1.1
Host: test.liveresource.org
Uri: </test>; If-None-Match="1456905833", </test2&after=1456909433>
Wait: 55
```

*Note: While it ought to be legal in the LiveResource protocol to send multiple `Uri` headers, the test server requires all URIs to be concatenated into a single `Uri` header, separated by commas. This is due to a limitation in Express.*

Response if neither resource changes in time:
```http
HTTP/1.1 200 OK
Content-Type: application/json

{
  "/test": {
    "code": 304,
    "headers": {
      "ETag": "\"1456905833\""
    },
    "body": ""
  },
  "/test2": {
    "code": 200,
    "headers": {
      "Link":"</test2?after=1456909433>; rel=changes"
    },
    "body": "{\"time:change\": \"+0\"}"
  }
}
```

Response if at least one of the resources has changed:
```http
HTTP/1.1 200 OK
Content-Type: application/json

{
  "/test": {
    "code": 200,
    "headers": {
      "ETag": "\"1456905843\""
    },
    "body": "{\"time\":<PHONE_NUMBER>}"
  }
}
```

### Streaming

The resources on the test server support streaming.

Requesting value stream:
```http
GET /test HTTP/1.1
Host: test.liveresource.org
Accept: text/event-stream
```

Initial response:
```http
HTTP/1.1 200 OK
Content-Type: text/event-stream
Transfer-Encoding: chunked

event: open
data:

```

Streamed value (wrapped for readability):
```http
event: update
data: {"Content-Type":"application/json",
    "ETag":"\"1456905843\"",
    "Previous-ETag":"\"1456905833\""}
data: {"time":1456905843}

```

If this were a changes stream instead of a value stream, updates would look like this (wrapped for readability):
```http
event: update
data: {"Content-Type":"application/json",
    "Link":"</test?after=1456905843>; rel=changes",
    "Changes-Id":"1456905843",
    "Previous-Changes-Id":"1456905833"}
data: {"time:change":"+10"}

```

The `Previous-ETag` and `Previous-Changes-Id` fields inside the updates can be used to detect missing data. The client can recover value data by polling the resource normally. The client can recover changes data by polling the last received `changes` link. To test client behavior in the absence of `Previous-ETag`, set the `no_previous` query parameter in the request.

### Reliable streaming

The server supports reliable streaming. To use it, pass the `reliable` query parameter. This parameter will also cause the server to advertise links with `mode=reliable`.

Querying for headers with reliability enabled:
```http
HEAD /test?reliable HTTP/1.1
Host: test.liveresource.org
```

Response:
```http
HTTP/1.1 200 OK
ETag: "1456905833"
Link: </test?reliable>; rel=value-stream; mode=reliable
Link: </test?reliable&after=1456905833>; rel=changes-stream; mode=reliable
Content-Type: application/json
```

Requesting reliable value stream:
```http
GET /test?reliable HTTP/1.1
Host: test.liveresource.org
Accept: text/event-stream
```

Initial response (wrapped for readability):
```http
HTTP/1.1 200 OK
Content-Type: text/event-stream
Transfer-Encoding: chunked

event: open
id:<PHONE_NUMBER>
data: {"Content-Type":"application/json",
    "ETag":"\"1456905833\""}
data: {"time":1456905833}

```

Streamed value (wrapped for readability):
```http
event: update
id:<PHONE_NUMBER>
data: {"Content-Type":"application/json",
    "ETag":"\"1456905843\""}
data: {"time":1456905843}

```

Requesting reliable changes stream, from an older checkpoint:
```http
GET /test?reliable&after=1456905830 HTTP/1.1
Host: test.liveresource.org
Accept: text/event-stream
```

Initial response (wrapped for readability):
```http
HTTP/1.1 200 OK
Content-Type: text/event-stream
Transfer-Encoding: chunked

event: open
id:<PHONE_NUMBER>
data: {"Content-Type":"application/json",
    "Link":"</test?after=1456905833>; rel=changes"}
data: {"time:change":"+3"}

```

Streamed changes (wrapped for readability):
```http
event: update
id:<PHONE_NUMBER>
data: {"Content-Type":"application/json",
    "Link":"</test?after=1456905843>; rel=changes"}
data: {"time:change":"+10"}

```

The server also supports SSE stream resumption if the client includes a `Last-Event-ID` header:
```http
GET /test?reliable&after=1456905830 HTTP/1.1
Host: test.liveresource.org
Accept: text/event-stream
Last-Event-ID:<PHONE_NUMBER>
```

The `Last-Event-ID` header takes precedence over any checkpoint information that may have been encoded in the URI.

### Socket

It is possible to stream multiple resources over a single WebSocket. There are 3 `multiplex-socket` endpoints:

* `/ws`: supports streaming `/test` or `/test2`.
* `/test/ws`: supports streaming `/test` only.
* `/test2/ws`: supports streaming `/test2` only.

The `no_share_multiplex` option can be used to tell the server to not advertise the same multiplex link for different resources. This can be useful to force clients to use different multiplex endpoints at the same time, for testing.

Once the socket is connected, requests can be issued.

Requesting a value stream:
```
GET /test
```

Acknowledgement response:
```
OK /test
```

Streamed value (wrapped for readability):
```
* /test {"Content-Type":"application/json",
    "ETag":"\"1456905843\"",
    "Previous-ETag":"\"1456905833\""}
{"time":1456905843}
```

Stop listening to a stream:
```
CANCEL /test
```

Acknowledgement response:
```
OK /test
```

Requesting a changes stream:
```
GET /test?changes
```

Acknowledgement response:
```
OK /test?changes
```

Streamed changes (wrapped for readability):
```
* /test?changes {"Content-Type":"application/json",
    "Link":"</test?after=1456905843>; rel=changes",
    "Changes-Id":"1456905843",
    "Previous-Changes-Id":"1456905833"}
{"time:change":"+10"}
```

The `Previous-ETag` and `Previous-Changes-Id` fields inside the updates can be used to detect missing data. The client can recover value data by polling the resource normally. The client can recover changes data by polling the last received `changes` link. To test client behavior in the absence of `Previous-ETag`, set the `no_previous` query parameter in the request.

### Reliable socket

The server supports reliable streaming through a WebSocket. To use it, include the `reliable` query parameter on the resources to listen on. Note that if you discover resource URIs via links, this parameter will already be included.

Requesting a reliable value stream:
```
GET /test?reliable
```

Acknowledgement response:
```
OK /test?reliable
```

Acknowledgement will be immediately followed by initial value (wrapped for readability):
```
* /test?reliable {"Content-Type":"application/json",
    "ETag":"\"1456905833\""}
{"time":1456905833}
```

Streamed value (wrapped for readability):
```
* /test {"Content-Type":"application/json",
    "ETag":"\"1456905843\""}
{"time":1456905843}
```

Requesting a reliable changes stream, from an older checkpoint:
```
GET /test?reliable&after=1456905830
```

Acknowledgement response:
```
OK /test?reliable&after=1456905830
```

Acknowledgement will be immediately followed by initial changes (wrapped for readability):
```
* /test?reliable&after=1456905830 {"Content-Type":"application/json",
    "Link":"</test?reliable&after=1456905833>; rel=changes"}
{"time:change":"+3"}
```

Streamed changes (wrapped for readability):
```
* /test?reliable&after=1456905830 {"Content-Type":"application/json",
    "Link":"</test?reliable&after=1456905843>; rel=changes"}
{"time:change":"+10"}
```

repository: liveresource/test-server

repo_name: liveresource/test-server


text:
[![Build Status](https://secure.travis-ci.org/revans/rack-signature.png)](https://travis-ci.org/revans/rack-signature)
[![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/revans/rack-signature)

# This is currently still being worked on and does have several known bugs.

This is an alpha release, a pre 1.0 version. If you use this, be aware it's in
its infancy.

# Rack::Signature

Rack Middleware used to verify signed requests.

## Installation

Add this line to your application's Gemfile:

    gem 'rack-signature'

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install rack-signature

## Usage

This is meant to be added to a Rails initializer like so:

```ruby
Rails.application.config.middleware.use Rack::Signature,
  klass: ClassWithSharedKey,
  method: 'method_within_class',
  header_token: 'http header used to hold the api key'
```
### Overview

This gem is assumed to be used within a rails application. It computes the HMAC
Signature internally and only sends a (single) request over the network when
Signatures fail to match; sending a 401. Otherwise, it makes no requests - only
accepts incoming JSON Api requests.

This gem will build an HMAC Signature based off an incoming request made to its
JSON Api initiated by some external client. Once it builds the "expected" HMAC
Signature, it will compare its Signature against the Signature that was sent by
the external client. If they match, the request is allowed to continue to the
Rails application. If it fails, this gem will send back a 401 response from its
own internal Rack application.

### Options explained:

#### klass

The name of the class within the rails application that can be used to query for
a model's shared key.

It is assumed that each consumer has it's own unique shared key; similar to
Oauth.

#### method

The method within the +klass+ that will be called to request a shared key to
build the HMAC. This is a class level method.

#### header_token

This is a bad name. It will be changed.

This is the name of the HTTP Header that holds the Api Key that is associated
with the consumer's account. It is used as the authentication as well as a way
to get the consumer's account to retreive the +shared key+.

## Contributing

1. Fork it
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

repository: revans/rack-signature

gha_language: Ruby

repo_name: revans/rack-signature


text:
# altcode.fake
FAKE helper code that I've written as a side-effect of other projects

## What's in the box?

For FAKE ≥ 5.23.0 or later for .net core

* [`AltCode.Fake.DotNet.Gendarme` ![Nuget](https://buildstats.info/nuget/AltCode.Fake.DotNet.Gendarme)](http://nuget.org/packages/altcode.fake.dotnet.gendarme), a gendarme helper along the lines of the FxCop task `Fake.DotNet.FxCop`

Can be used with the most recent [homebrew release from my fork](https://www.nuget.org/packages/altcode.gendarme/) to analyze netcore/netstandard builds.

DotNet global tools

*  [`AltCode.VsWhat` ![Nuget](https://buildstats.info/nuget/AltCode.VsWhat)](http://nuget.org/packages/altcode.vswhat), a tool to list Visual Studio instances and their installed packages; a thin wrapper over [BlackFox.VsWhere](https://github.com/vbfox/FoxSharp/blob/master/src/BlackFox.VsWhere/Readme.md) to make this one specific query.

## Continuous Integration

| | | |
| --- | --- | --- |
| **Build**  | GitHub [![Build status](https://github.com/SteveGilham/altcode.fake/workflows/CI/badge.svg)](https://github.com/SteveGilham/altcover/altcode.fake?query=workflow%3ACI) | [![Build history](https://buildstats.info/github/chart/SteveGilham/altcode.fake?branch=master)](https://github.com/SteveGilham/altcode.fake/actions?query=workflow%3ACI)|
| **Unit Test coverage** | Coveralls | [![Coverage Status](https://coveralls.io/repos/github/SteveGilham/altcode.fake/badge.svg?branch=master)](https://coveralls.io/github/SteveGilham/altcode.fake?branch=master) |

## Usage

See the [Wiki page](https://github.com/SteveGilham/altcode.fake/wiki) for details

## Building

### Tooling

#### All platforms

It is assumed that the following are available

.net core SDK 7.0.100 or later (`dotnet`) -- try https://www.microsoft.com/net/download

#### Windows

You will need Visual Studio VS2022 (Community Edition) latest with F# language support (or just the associated build tools and your editor of choice).

#### *nix

It is assumed that the latest `mono`, and `dotnet` are on the `PATH` already, and everything is built from the command line, with your favourite editor used for coding.

### Bootstrapping

Start by setting up `required tools with `dotnet tool restore`
Then `dotnet run --project ./Build/Setup.fsproj` to do the rest of the set-up.

### Normal builds

Running `dotnet run --project ./Build/Build.fsproj` performs a full build/test/package process.

Use `dotnet run --project ./Build/Build.fsproj --target <targetname>` to run to a specific target.

## Thanks to

* [Coveralls](https://coveralls.io/r/SteveGilham/altcode.fake) for allowing free services for Open Source projects

gha_language: F#

gha_license_id: MIT


text:
# Version 0.13.2

Update the dependencies. Remove the logo (see [168](https://github.com/avli/clojureVSCode/issues/168)).

# Version 0.13.1

Updates the embedded nREPL dependencies. Add settings for explicitly setting these dependencies versions.

# Version 0.13.0

Adds the ability to show evaluation results inline:

![inline-results](https://user-images.githubusercontent.com/1375411/74069697-13c79300-4a10-11ea-9faf-3c2e09c55675.gif)

Adds the ability to show a large evaluation result [#134](https://github.com/avli/clojureVSCode/issues/134).

# Version 0.12.0

Uses VSCode built-in formatting provider to format code [#90](https://github.com/avli/clojureVSCode/issues/90).

# Version 0.11.3

Bundles the extension in order to minimize its size.

# Version 0.11.2

Makes it possible to pick definitions from JAR files (Clojure only) [#111](https://github.com/avli/clojureVSCode/issues/111).

# Version 0.11.1

Fix-up release. Reenable automatic nREPL starting.

# Version 0.11.0

Adds the ability to evaluate blocks of code without selection [#61](https://github.com/avli/clojureVSCode/issues/61):

![eval-block](https://user-images.githubusercontent.com/1375411/68340984-874bc280-00f8-11ea-9eea-34c7160b8c05.gif)

Use the "Clojure: Eval and show the result command" for evaluation of the current
code block and "Clojure: Eval" for the outer.

Fixes the issue with completion in the middle of a line [#139](https://github.com/avli/clojureVSCode/issues/139).

# Version 0.10.5

Fix namespace evaluation for modules beginning with a semicolon.

# Version 0.10.4

Show the full stacktrace on an evaluation error.

# Version 0.10.3

Updates the embedded nREPL cider-nrepl version.

# Version 0.10.2

Output window now preserves focus.

# Version 0.10.1

Fixes the issue with the "Eval" command.

# Version 0.10.0

Adds integration with Clojure unit test framework.

![Test results UI demo](https://user-images.githubusercontent.com/448001/39921203-ee8e30b6-5511-11e8-843a-690dd8624b87.gif)

# Version 0.9.8

Temporary removes `refactor-nrepl` from the dependencies of the embedded nREPL at least untile [this issue](https://github.com/clojure-emacs/refactor-nrepl/issues/206) won't be fixed.

# Version 0.9.7

Fixes the behavior of nREPL connection. If a remote nREPL is closed evaluation of code will show the message about it and the connection indicator will be removed.

# Version 0.9.6

Adds the [Connecting to the REPL](https://github.com/avli/clojureVSCode#connecting-to-the-repl) section to README.md and Slightly changes the behavior of the nREPL output channel only bringing it to the foreground on error.

# Version 0.9.5

Adds a channel for nREPL output to the Output Window.

# Version 0.9.4

Adds the `:headless` option to the embedded nREPL and [clojure-warrior](https://marketplace.visualstudio.com/items?itemName=tonsky.clojure-warrior) to the extension recommendations.

# Version 0.9.3

Adds support of `cljfmt` options.

# Version 0.9.2

Adds Clojure 1.9 support.

# Version 0.9.1

Adds a configuration option for formatting code on save.

# Version 0.9.0

Adds experimental ClojureScript support. Please check out [README.md](https://github.com/avli/clojureVSCode#clojurescript-project-setup) to learn how to use the extension for ClojureScript.

# Version 0.8.2

Fixes the issue with unescaping newlines that are parts of a string [#64](https://github.com/avli/clojureVSCode/issues/64).

# Version 0.8.1

Adds a configuration option to disable an embedded nREPL start.

# Version 0.8.0

Adds code formatting support [#57](https://github.com/avli/clojureVSCode/issues/57).

# Version 0.7.10

Adds workaround for the hanging Java process issue on the Windows platform [#56](https://github.com/avli/clojureVSCode/issues/56).

# Version 0.7.9

Hotfix that detaches nREPL process on UNIX and non-detached one on Windows [#56](https://github.com/avli/clojureVSCode/issues/56).

# Version 0.7.8

Fixes the troubles with a hanging Java process [#56](https://github.com/avli/clojureVSCode/issues/56).

# Version 0.7.7

Fixes the error with embedded nREPL on Windows.

# Version 0.7.6

Does code refactoring and minor nREPL connection indicator UI fixes.

# Version 0.7.5

Fixes the `Unable to start nREPL` bug [#47](https://github.com/avli/clojureVSCode/issues/47).

# Version 0.7.4

Fixes the nREPL connection indicator behavior [#42](https://github.com/avli/clojureVSCode/issues/42).

# Version 0.7.3

Fixes typos in documentation.

# Version 0.7.2

Fixes README.md formatting to display correctly on the Visual Studio Marketplace web-site.

# Version 0.7.1

Fixes the links to the images in README.md.

# Version 0.7.0

Adds embedded nREPL functionality – no need to connect manually anymore.
[#21](https://github.com/avli/clojureVSCode/issues/21).

# Version 0.6.1

Adds the forgotten changelog for the version 0.6.0 :-)

# Version 0.6.0

Changes the behavior of the `Eval` command - now it shows compilation errors in the `Output` panel [#28](https://github.com/avli/clojureVSCode/issues/28).

# Version 0.5.4

Fixes possible bug with missing return from the `provideDefinition` function [#26](https://github.com/avli/clojureVSCode/issues/26).

# Version 0.5.3

Cleans up the documentation a little

# Version 0.5.2

Improves better support of special form signatures.

# Version 0.5.1

Updates the information about the supported features.

# Version 0.5.0

Adds signature helper [#6](https://github.com/avli/clojureVSCode/issues/8).

# Version 0.4.3

Fixes the issue when only one output line is printed [#9](https://github.com/avli/clojureVSCode/issues/9).

# Version 0.4.2

Shows output of the "Eval" command [#5](https://github.com/avli/clojureVSCode/issues/5).

# Version 0.4.0

The first version public version.

repository: avli/clojureVSCode

gha_language: TypeScript

repo_name: avli/clojureVSCode


text:
# ERDOS

ERDOS is a platform for developing self-driving cars and robotics applications.

[![Crates.io][crates-badge]][crates-url]
[![Build Status](https://travis-ci.org/erdos-project/erdos.svg)](https://travis-ci.org/erdos-project/erdos)
[![Documentation Status](https://readthedocs.org/projects/erdos/badge/?version=latest)](https://erdos.readthedocs.io/en/latest/?badge=latest)
[![Documentation](https://docs.rs/erdos/badge.svg)](https://docs.rs/erdos/0.2.0/erdos/)

[crates-badge]: https://img.shields.io/crates/v/erdos.svg
[crates-url]: https://crates.io/crates/erdos

# Getting started

The easiest way to get ERDOS running is to use our Docker image:

```console
docker pull erdosproject/erdos
```

# Local installation

## System requirements

ERDOS is known to work on Ubuntu 16.04, 18.04, and 19.10.

## Installation

```console
git clone https://github.com/erdos-project/erdos.git && cd erdos

python3 python/setup.py develop
```

This script installs Python and Rust dependencies in addition to ERDOS.

## Running an example

```console
python3 python/examples/simple_pipeline.py
```

# Writing Applications

ERDOS provides Python and Rust interfaces for developing applications.

The Python interface provides easy integration with popular libraries
such as tensorflow, but comes at the cost of performance
(e.g. slower serialization and the [lack of multithreading](https://wiki.python.org/moin/GlobalInterpreterLock)).

The Rust interface provides more safety guarantees
(e.g. compile-time type checking) and faster performance
(e.g. multithreading and zero-copy message passing).
High performance, safety critical applications such as
self-driving car pipelines deployed in production should use the
Rust API to take full advantage of ERDOS.

# ERDOS Design

ERDOS is a streaming dataflow system designed for self-driving car
pipelines and robotics applications.

Components of the pipelines are implemented as **operators** which
are connected by **data streams**. The set of operators and streams
forms the **dataflow graph**, the representation of the pipline that
ERDOS processes.

Applications define the dataflow graph by connecting operators to streams
in the **driver** section of the program. Operators are typically
implemented elsewhere.

ERDOS is designed for low latency. Self-driving car pipelines require
end-to-end deadlines on the order of hundreds of milliseconds for safe
driving. Similarly, self-driving cars typically process gigabytes per
second of data on small clusters. Therefore, ERDOS is optimized to
send small amounts of data (gigabytes as opposed to terabytes)
as quickly as possible.

ERDOS provides determinisim through **watermarks**. Low watermarks
are a bound on the age of messages received and operators will ignore
any messages older than the most recent watermark received. By processing
on watermarks, applications can avoid non-determinism from processing
messages out of order.

# Getting involved

If you would like to contact us, please send an email to:
<EMAIL_ADDRESS>or create an issue on GitHub.

We always welcome contributions to ERDOS. One way to get started is to
pick one of the issues tagged with **good first issue** -- these are usually good issues that help you familiarize yourself with the ERDOS
code base. Please submit contributions using pull requests.

repository: jasminevle/erdos

repo_name: jasminevle/erdos


text:
prakitpy
====
This provides a little script to handle tables in textfiles (similar, but more powerful, to numpy.genfromtxt()).

# Using Matplotlib

Praktipy will try to set up the matplotlib backend to enable printing of beautiful (german number format and nice math-font) plots. If you want to set up matplotlib yourself, just do that before you import anything from praktipy.

# Documentation

The code currently is not very well documented (Allthough tablehandler.py itself provides nice Docstrings).
You will find some examples in ./examples/, which you can use for orientation.

# Dependencies
* python
* numpy
* uncertainties
* pint

Please install numpy, uncertainties with the following commands (using pip).
~~~sh
$ pip install numpy
$ pip install uncertainties
$ pip install pint
~~~

# Installation
For now: execute install.bash. Maybe I will add a nicer version later (which is in tone to the rest of python).
~~~sh
$ ./install.bash
~~~

# Thanks
Thanks a lot to [PEP et al.](https://pep-dortmund.org/) for their [Toolbox-Workshop](https://toolbox.pep-dortmund.org/notes.html) and materials they provide. I basicly stole their matplotlib-tex-header!

repository: phenomax/praktipy

repo_name: phenomax/praktipy


text:
## A diagnostic tool to help compare where GBIF and VertNet counts differ

To build: ```npm install```

To run: ```gulp```

To view: ```http://localhost:8080```


text:
# multi-pdf-finder

**Are you searching a word in many pdf files? Do it one time.** ⚡

![python-version](https://github.com/edoardottt/images/blob/main/multi-pdf-finder/python-version.svg)
![ubuntu-build](https://github.com/edoardottt/images/blob/main/multi-pdf-finder/ubuntu-build.svg)

Description 🔦
-------

It only requires `pdftotext` command.
Easily create a folder called 'find_result', then commute all pdf files in the folder input as txt files and searches into them for the input word.

Download 📡
-------

```bash
git clone https://github.com/edoardottt/multi-pdf-finder
```

Usage 🚀
--------

```bash
./find.sh [ -f folder ] [ -w word ]
```
Example (Here I'm searching for the word `edoardottt` in all the PDF files in the folder called pdf_files) :
```bash
./find.sh -f pdf_files/ -w "edoardottt"
```

Contributing 🤝
------
If you want to contribute to this project, you can start opening an [issue](https://github.com/edoardottt/multi-pdf-finder/issues).

---------

[edoardoottavianelli.it](https://www.edoardoottavianelli.it/) to contact me.

repository: edoardottt/multi-pdf-finder

repo_name: edoardottt/multi-pdf-finder


text:
# How to use

1. build specplast comtainer
2. run `docker-compose up`
3. login to `web` container `docker-compose exec web bash` and run

   rake db:create
   rake db:migrate
   rake db:seed

4. Now you can see something at localhost:3000

# Steps

1. Created good Dockerfile

2. Build image with tag name

   docker build -t specplast01 .

3. Use postgres docker images env varialbes from https://hub.docker.com/_/postgres

# Troubleshooting:

1. to run image do

   docker run -i -t specplast01 /bin/bash

2. bundle is not found error:

   https://github.com/docker-library/ruby/issues/24

3. Rmagic can't be installed

   Use imagemagic of same version (6.7.7-10) as on prod.

repository: ziraqyoung/specplast

repo_name: ziraqyoung/specplast


text:
# Symbol vs String

In most query building methods, we allow symbols and strings to be given as parameter.

While not being always true, when using `Symbol`, Clear will try to escape the word using double quote during the request building, while `String` will be printed out as it.

```ruby
# SELECT * FROM "users" INNER JOIN "orders" on "order_id" == "orders"."id"
User.query.join(:orders){order_id == orders.id }

# SELECT * FROM "users" INNER JOIN orders on "order_id" == "orders"."id"
User.query.join("orders"){order_id == orders.id }
```

In case of wrong behavior, do not hesitate to [fill an issue here](https://github.com/anykeyh/clear/issues).

repository: anykeyh/clear

gha_language: Crystal

repo_name: anykeyh/clear


text:
---
title: oVirt Metrics Store - Installation Guide
category: feature
authors: sradco
feature_name: oVirt Metrics Store Installation
feature_modules: engine
feature_status: In Development
---
# oVirt Metrics - Installation Guide

[![oVirt Metrics data flow](/images/wiki/oVirtMetricsDataFlow.jpg)](/images/wiki/oVirtMetricsDataFlow.jpg)

## oVirt Metrics Store Setup

**Note:** Currently, the oVirt Metrics Store should be installed on a new machine, separate from the engine.
It can be installed on a dedicated VM.

### Metrics Store Machine Prerequisites

For an oVirt environment with 50 hosts:
- 4 CPU cores, 16GB RAM memory .
- We recommends using SSD disks.
- CentOS 7.3 or later.
- Preallocated 500GB partition - It will be used for persistent storage. Use a partition other than root (/) to avoid filling up the partition, for example, /var.
- Add the Metrics Store Machine FQDN to your enterprise hostname resolution system, for example, DNS.
Add the following aliases:

    - es.FQDN for Elasticsearch
    - kibana.FQDN for Kibana

    where FQDN is the hostname and domain of the OpenShift Aggregated Logging machine.
- Also please make sure to follow the [OpenShift `masters` prerequisites](https://docs.openshift.org/latest/install_config/install/prerequisites.html#hardware)

### Update config.yml file

1. Copy  /etc/ovirt-engine-metrics/config.yml.example  to config.yml.

   On the oVirt engine machine, run:

        # cp /etc/ovirt-engine-metrics/config.yml.example /etc/ovirt-engine-metrics/config.yml

2. Update the file /etc/ovirt-engine-metrics/config.yml located on the engine machine, with the following lines:

        # vi /etc/ovirt-engine-metrics/config.yml

3. Update the values to match the details of your specific environment:

- `ovirt_env_name:` **Please update this parameter**.

  Environment name. It is used to identify data collected in a single central
  store, sent from more than one oVirt engine.

  Use the following convention:

  - Include only alphanumeric characters and hyphens ( "-" ).
  - Name cannot begin with a hyphen or a number, or end with a hyphen.
  - Maximum of 49 characters. Wildcard patterns (e.g. ovirt-metrics*) cannot be used.

- `fluentd_elasticsearch_host:` (required - no default value)

  Address or hostname (FQDN) of the Elasticsearch server host.

### Configure SSH Key-Based Authentication between engine and metrics store machine

To copy the engine public key to your metrics store machine, run:

    # mytemp=$(mktemp -d)

    # cp /etc/pki/ovirt-engine/keys/engine_id_rsa $mytemp

    # ssh-keygen -y -f $mytemp/engine_id_rsa > $mytemp/engine_id_rsa.pub

    # ssh-copy-id -i $mytemp/engine_id_rsa.pub root@{fluentd_elasticsearch_host}

It should ask for root password (on first attempt), supply it.
After that, run:

    # rm -rf $mytemp

To test that you are able to log into the metrics store machine from the engine, run:

    # ssh -i /etc/pki/ovirt-engine/keys/engine_id_rsa root@{fluentd_elasticsearch_host}

### Run ovirt-metrics-store-installation playbook

This playbook generates the inventory and vars.yml files required for the metrics store installation and copies them
to the metrics store machine.

        # /usr/share/ovirt-engine-metrics/setup/ansible/configure_ovirt_machines_for_metrics.sh \
        --playbook=ovirt-metrics-store-installation.yml

### Metrics Store Installation

**Note:** When running ansible to configure OpenShift, use the ansible-inventy file based on your OpenShift version and flavor.

To install OpenShift Logging on your machine (Elasticsearch, Kibana, Fluentd, Curator), Please follow the installation instructions: [Metrics Store setup on top of OpenShift](https://www.ovirt.org/develop/release-management/features/metrics/setting-up-viaq-logging/)

Optional in oVirt 4.2, add SSO: [Metrics Store setup on top of OpenShift with oVirt Engine SSO](https://www.ovirt.org/blog/2017/05/openshift-openId-integration-with-engine-sso/)

Once you have finished this step, you should have:

  * Kibana - <https://kibana.{fluentd_elasticsearch_host}>
  * OpenShift portal - <https://{fluentd_elasticsearch_host}:8443>

## oVirt Hypervisors and Engine Setup ##

Deploy and configure collectd and fluentd to send the data to the central metrics store::

1. This requires installing / upgrading and setting up oVirt Engine latest 4.2.z.

2. This requires installing / upgrading and activating one or more hosts from version 4.2.z.

3. On the engine machine, run as root:

        # /usr/share/ovirt-engine-metrics/setup/ansible/configure_ovirt_machines_for_metrics.sh

It runs the Ansible script that configures collectd and fluentd on the oVirt engine and hypervisors.

It should finish without errors, collectd and fluentd services should be running.

Once finished, you can view host, VM and other statistics, in the Kibana console,
at the address configured earlier on in this procedure [(see oVirt Metrics Store Setup)](https://github.com/ViaQ/Main/blob/master/README-install.md#running-kibana).

## Example Dashboards

Kibana should be available at <https://kibana.{fluentd_elasticsearch_host}>

Dashboard examples include `System Dashboard`, `Hosts Dashboard`, `VMs Dashboard`, `Processes Dashboard`.

If you wish to import dashboards example, you will need to import visualization and dashboards manually from the Kibana UI.

1. Copy the /etc/ovirt-engine-metrics/dashboards-examples directory to your local machine.

2. Go to the Kibana UI, to the `setting` tab -> `indices`.

3. Select the `project.ovirt-metrics-<ovirt-env-name>.<uuid>` index.

4. Press the orange button, `Refresh field list`.

5. Do steps 3 and 4 for the `project.ovirt-logs-<ovirt-env-name>.<uuid>` index.

6. In the Kibana UI, go to the `setting` tab -> `objects`.

7. Import the `Searches`.

8. Import the `Visualizations`.

9. Import the `Dashboards`.

You are done! Go to the `Dashboard` tab in the Kibana UI and choose a dashboard.

Currently there are 3 example dashboards:

  * System Dashboard - https://kibana.{fluentd_elasticsearch_host}/app/kibana#/dashboard/System-Dashboard

  * Hosts Dashboard - https://kibana.{fluentd_elasticsearch_host}/app/kibana#/dashboard/Hosts-Dashboard

  * VMs Dashboard - https://kibana.{fluentd_elasticsearch_host}/app/kibana#/dashboard/VMs-Dashboard

**Note:** If you get an error while loading the `Visualizations`, check your hosts and make sure Collectd and Fluentd services are running with no errors. After that try loading the `Visualizations` again.

repository: Gal-Zaidman/ovirt-site

repo_name: Gal-Zaidman/ovirt-site


text:
---
prompt: "Resin"
phase: "Sagittarius"
start_date: "11/22/2020"
end_date: "12/21/2020"
calendar_system: "Calendar System"
location: "Los Angeles, CA, USA; Toronto, ON, Canada"
lat_lon: "34.0522° N, 118.2437° W;43.6532° N, 79.3832° W"
place: "Los Angeles River Watershed;?"
creator: "Chacha Sikes"
author: "Chacha Sikes"
collaborators: "TBD"
hashtag: "#quartermoonnights"
instagram: "@redbeakstudio"
language: "en-us"
network: "Storybox"
timezone: "GMT-7"
senses: "scent,sight,touch"
portal: "https://storybox.redbeakstudio.com/guid"
network: "Storybox"
captions: "https://storybox.redbeakstudio.com/guid/captions"
api: "https://storybox.redbeakstudio.com/guid/json"
comfort_level: "Comfortable"
rating: ""
version: "v0.0.1"
github: "https://github.com/redbeakstudio/quartermoonnights"
---
# Quarter Moon Nights: Capricorn 2020 | Resin
## Topics: Resin, Wood, Pano-sketching, Foraging
| Name                 | Phase           |  Date         | Calendar System |
| :----------          | :-------------: | -----------:  | --------------: |
| Moon Phase           | Waxing Moon     | 11/21/2020    | Lunar           |
| Sagitarrius (start)  | House           | 11/22/2020    | Western Zodiac  |
| Moon Phase           | Full Moon       | 11/30/2020    | Lunar           |
| Dark Moon            | Full Moon       | 11/30/2020    | Celtic (*)      |
| December             | Month           | 12/1/2020     | Gregorian       |
| Moon Phase           | Waning Moon     | 12/7/2020     | Lunar           |
| Moon Phase           | New Moon        | 12/14/2020    | Lunar           |
| Moon Phase           | Waxing Moon     | 12/21/2020    | Lunar           |
| Solstice             | Winter          | 12/21/2020    | Solar           |
| Capricorn (end)      | House           | 12/22/2020    | Western Zodiac  |

## Prompt
**Resin**

## Phase
**Capricorn**

## Project
**Resin, Wood & Pano-sketching**

* [Brief](Brief.md)

## Resources
* [Lunar Development](Lunar-Development.md)
* [Scent Kits](Scent-Kits.md)
* [Scheduling](Scheduling.md)
* [Google Calendar](https://calendar.google.com/calendar/u/1?cid=Y191OTc1YnBmM25ubDFka3MxdWZxaHVnbzltNEBncm91cC5jYWxlbmRhci5nb29nbGUuY29t)

repository: redbeakstudio/quartermoonnights

branch_name: refs/heads/main

repo_name: redbeakstudio/quartermoonnights


text:
# smmdb-api
An easy-to-use Java-API for accessing the [SMMDB-API](https://github.com/Tarnadas/smmdb/#public-api)</a> with [POJOs](https://en.wikipedia.org/wiki/Plain_old_Java_object).

### Functionalities
- Getting the server stats of SMMDB
- Getting and filtering courses from SMMDB (including Super Mario Maker 64 courses)
- Downloading the courses

### ToDo:
- Uploading of courses
- Starring and unstarring courses

### Maven
For binding in the API in your project with Maven, add these lines of code between your "**\<repositories>**" tags:
```xml
<repository>
      <id>FluentCoding-smmdb-api</id>
      <url>https://packagecloud.io/FluentCoding/smmdb-api/maven2</url>
</repository>
```
... and these between your "**\<dependencies\>**" tags:
```xml
<dependency>
      <groupId>io.fluentcoding</groupId>
      <artifactId>smmdb-api</artifactId>
      <version>LATEST</version>
</dependency>
```

### Gradle
For binding in the API in your project with Gradle, add this:
```gradle
repositories {
      // ...
      maven {
        url "https://packagecloud.io/FluentCoding/smmdb-api/maven2"
      }
}
// ...
compile 'io.fluentcoding:smmdbapi:1.0'
```

### Documentation
To see more information about the detailed usage of this API, visit [this](https://zsuckylp.gitbook.io/workspace/) page.

### More...
For more information about the smmdb project, visit the server at https://smmdb.ddns.net.

repository: FluentCoding/smmdb-api

gha_language: Java

repo_name: FluentCoding/smmdb-api


text:
# Storage

This document explains how to get started using Azure Storage Service with Fog. With this gem you can create, update, list or delete storage accounts.

## Usage

First of all, you need to require the Fog library by executing:

```ruby
require 'fog/azurerm'
```

## Create Connection

Next, create a connection to the Storage Service:

```ruby
fog_storage_service = Fog::Storage::AzureRM.new(
  tenant_id: '<Tenant Id>',                                                          # Tenant Id of Azure Active Directory Application
  client_id:    '<Client Id>',                                                       # Client Id of Azure Active Directory Application
  client_secret: '<Client Secret>',                                                  # Client Secret of Azure Active Directory Application
  subscription_id: '<Subscription Id>',                                              # Subscription Id of an Azure Account
  azure_storage_account_name: '<Storage Account Name>',                              # Name of an Azure Storage Account
  azure_storage_access_key: '<Storage Account Key>',                                 # Key of an Azure Storage Account
  environment: '<AzureCloud/AzureChinaCloud/AzureUSGovernment/AzureGermanCloud>'     # Azure cloud environment. Default is AzureCloud.
)
```

If you only want to manage the storage accounts, you can create the connection without the storage account information:

```ruby
fog_storage_service = Fog::Storage::AzureRM.new(
  tenant_id:        '<Tenant Id>',                                                         # Tenant Id of Azure Active Directory Application
  client_id:        '<Client Id>',                                                         # Client Id of Azure Active Directory Application
  client_secret:    '<Client Secret>',                                                     # Client Secret of Azure Active Directory Application
  subscription_id:  '<Subscription Id>',                                                   # Subscription Id of an Azure Account
  environment:      '<AzureCloud/AzureChinaCloud/AzureUSGovernment/AzureGermanCloud>'      # Azure cloud environment. Default is AzureCloud.
)
```

If you only want to manage the storage data, you can create the connection without the Azure subscription information:

```ruby
fog_storage_service = Fog::Storage::AzureRM.new(
  azure_storage_account_name:   '<Storage Account Name>',                                             # Name of an Azure Storage Account
  azure_storage_access_key:     '<Storage Account Key>',                                              # Key of an Azure Storage Account
  environment:                  '<AzureCloud/AzureChinaCloud/AzureUSGovernment/AzureGermanCloud>'     # Azure cloud environment. Default is AzureCloud.
)
```

## Check Name Availability

This operation checks that account name is valid and is not already in use. _Storage Account Type_ is an optional parameter

```ruby
fog_storage_service.storage_accounts.check_name_availability('<Storage Account Name>', '<Storage Account Type>')
```

## Check Storage Account Existence

```ruby
fog_storage_service.storage_accounts.check_storage_account_exists('<Resource Group Name>', '<Storage Account Name>')
```

## Create Storage Account

Create a new storage account. Replication attribute for Standard and Premium account types are as follows

##### Standard

1. LRS (Standard Locally-redundant storage)
2. ZRS (Standard Zone-redundant storage)
3. GRS (Standard Geo-redundant storage)
4. RAGRS (Standard Read access geo-redundant storage)

##### Premium
1. LRS (Premium Locally-redundant storage)

```ruby
fog_storage_service.storage_accounts.create(
  name:           '<Storage Account name>',
  location:       '<Location>',
  resource_group: '<Resource Group Name>',
  account_type:   '<Standard/Premium>',                                   # [Optional] Default value 'Standard'. Allowed values can only be Standard or Premium
  replication:    '<Replication Type>',                                    # [Optional] Default value 'LRS'
  encryption:     <True/False>,                                           # [Optional] Enables encryption. Default is false.
  tags:           { key1: 'value1', key2: 'value2', keyN: 'valueN' }       # [Optional]
)
```
Premium Storage account store data on solid state drives (SSDs). For more details on standard and premium storage accounts, see [Introduction to Microsoft Azure Storage](https://azure.microsoft.com/en-us/documentation/articles/storage-introduction/) and [Premium Storage: High-Performance Storage for Azure Virtual Machine Workloads](https://azure.microsoft.com/en-us/documentation/articles/storage-premium-storage/).

## List storage accounts

##### List storage accounts in a subscription

```ruby
fog_storage_service.storage_accounts.each do |storage_acc|
  puts "#{storage_acc.name}"
  puts "#{storage_acc.location}"
end
```
##### List storage accounts in a resource group

```ruby
storage_accounts  = fog_storage_service.storage_accounts(resource_group: '<Resource Group Name>')
storage_accounts.each do |storage_acc|
  puts "#{storage_acc.name}"
  puts "#{storage_acc.location}"
end
```

## Retrieve a single Storage Account

Get a single record of Storage Account

```ruby
storage_acc = fog_storage_service
                .storage_accounts
                .get('<Resource Group Name>', '<Storage Account Name>')
puts "#{storage_acc.name}"
```

## Enable encryption on Storage Account

Get a single record of Storage Account and enable encryption on that Storage Account

```ruby
storage_acc = fog_storage_service
                .storage_accounts
                .get('<Resource Group Name>', '<Storage Account Name>')

storage_acc.update(encryption: true)
```

## Get Access Keys

Get access keys of a storage account

```ruby
keys_hash = storage_acc.get_access_keys
keys_hash.each do |keys|
  puts "#{keys.key_name}:  #{keys.value}"
end
```

## Destroy a single Storage Account

Get storage account object from the get method and then destroy that storage account.

```ruby
storage_acc.destroy
```

## Create a Disk

Create a Disk in storage account. _disk_size_in_gb_ must be an integer and the range is [1, 1023].
By default the disk will be created in the container 'vhds'. You can specify other container by set options[:container_name].

```ruby
fog_storage_service.create_disk('<Data Disk Name>', disk_size_in_gb, options = {})
```

## Delete a Disk

Delete a Disk from a storage account. Disk must be in unlocked state i.e detached from server (virtual machine) to successfully perform this action.
By default the disk will be deleted from the container 'vhds'. You can specify other container by set options[:container_name].

```ruby
fog_storage_service.delete_disk('<Data Disk Name>', options = {})
```

## Check Storage Container Existence

```ruby
fog_storage_service.directories.check_container_exists('<Container Name>')
```

## Create a storage container

Create a storage container in the current storage account.

```ruby
directory = fog_storage_service.directories.create(
   key: '<Container Name>',
   public: <True/False>
)
puts directory.key
```

## List storage containers

List all the storage containers in the current storage accounts.

```ruby
fog_storage_service.directories.each do |directory|
  puts directory.key
end
```

## Get the access control level of the storage container

Get the permissions for the specified container. The permissions indicate whether container data may be accessed publicly.

```ruby
directory = fog_storage_service.directories.get('<Container Name>', max_keys: <Maximum No. of Keys Value>)
puts directory.acl
```

## Set the access control level of the storage container

Set the permissions for the specified container. The permissions indicate whether container data may be accessed publicly. The container permissions provide the following options for managing container access:

  - ###### Container

    Full public read access. Container and blob data can be read via anonymous request. Clients can enumerate blobs within the container via anonymous request, but cannot enumerate containers within the storage account.

  - ###### Blob

    Public read access for blobs only. Blob data within this container can be read via anonymous request, but container data is not available. Clients cannot enumerate blobs within the container via anonymous request.

  - ###### Nil

    No public read access. Container and blob data can be read by the account owner only.

```ruby
directory = fog_storage_service.directories.get('<Container Name>', max_keys: <Maximum No. of Keys Value>)
directory.acl = '<Container Name>'
directory.save(is_create: <True/False>)
```

## Delete the storage container

Mark the specified container for deletion. The container and any blobs contained within it are later deleted during garbage collection.

```ruby
directory = fog_storage_service.directories.get('<Container Name>', max_keys: <Maximum No. of Keys Value>)
puts directory.destroy
```

## Upload data as a block blob
```ruby
directory = fog_storage_service.directories.get('<Container Name>', max_keys: <Maximum No. of Keys Value>)
options = {
  key: '<Blob Name>',
  body: '<Blob Content>'
}
new_block_blob = directory.files.create(options)
puts new_block_blob.inspect
```

## Upload a local file as a block blob
```ruby
directory = fog_storage_service.directories.get('<Container Name>', max_keys: <Maximum No. of Keys Value>)
File.open('<File Path>') do |file|
  options = {
    key: '<Blob Name>',
    body: file
  }
  new_block_blob = directory.files.create(options)
  puts new_block_blob.inspect
end
```

## Upload VHD data as a page blob
```ruby
directory = fog_storage_service.directories.get('<Container Name>', max_keys: <Maximum No. of Keys Value>)
options = {
  key: '<Blob Name>',
  body: '<Blob Content>',
  blob_type: '<Blob Type>'
}
new_page_blob = directory.files.create(options)
puts new_page_blob.inspect
```

## Upload a local VHD as a page blob
```ruby
directory = fog_storage_service.directories.get('<Container Name>', max_keys: <Maximum No. of Keys Value>)
File.open('<File Path>') do |file|
  options = {
    key: '<Blob Name>',
    body: file,
    blob_type: '<Blob Type>'
  }
  new_page_blob = directory.files.create(options)
  puts new_page_blob.inspect
end
```

## Copy Blob from one container to another
```ruby
directory = fog_storage_service.directories.get('<Source Container Name>', max_keys: <Maximum No. of Keys Value>)
copied_blob = directory.files.head('<Source Blob Name>').copy('<Destination Container Name>', '<Destination Blob Name>')
puts copied_blob.inspect
```

## Copy Blob from one uri to self
```ruby
directory = fog_storage_service.directories.get('<Destination Container Name>', max_keys: <Maximum No. of Keys Value>)
copied_blob = directory.files.new(key: '<Destination Blob Name>')
copied_blob.copy_from_uri('<Source Blob Uri>')
puts copied_blob.inspect
```

## Download a small blob to a local file
```ruby
directory = fog_storage_service.directories.get('<Container Name>', max_keys: <Maximum No. of Keys Value>)
blob = directory.files.get('<Blob Name>')
File.open('<File Path>', 'wb') do |file|
  file.write(blob.body)
end
puts "File Size: #{::File.size <File Path>}"
```

## Download a large blob to a local file
```ruby
directory = fog_storage_service.directories.get('<Container Name>', max_keys: <Maximum No. of Keys Value>)
File.open('<File Path>', 'wb') do |file|
  directory.files.get('<Blob Name>') do |chunk, remaining_bytes, total_bytes|
    puts "remaining_bytes: #{remaining_bytes}, total_bytes: #{total_bytes}"
    file.write(chunk)
  end
end
puts "File Size: #{::File.size <File Path>}"
```

## Delete the storage blob

Mark the specified blob for deletion. The blob is later deleted during garbage collection.

```ruby
directory = fog_storage_service.directories.get('<Container Name>', max_keys: <Maximum No. of Keys Value>)
blob = directory.files.head('<Blob Name>')
puts blob.destroy
```

## Set storage blob properties

Set the storage blob properties.

```ruby
directory = fog_storage_service.directories.get('<Container Name>', max_keys: <Maximum No. of Keys Value>)
blob = directory.files.head('<Blob Name>')
blob.content_language = '<Language>'
blob.content_disposition = '<Content Disposition Type>'
blob.save(update_body: <True/False>)
```

## Metadata

Metadata allows us to provide descriptive information about specific containers or blobs. This is simply providing name/value pairs of data we want to set on the container or blob.

### Get Blob Metadata

```ruby
directory = fog_storage_service.directories.get('<Container Name>', max_keys: <Maximum No. of Keys Value>)
blob = directory.files.head('<Blob Name>')
puts blob.metadata
```

### Set Blob Metadata

```ruby
directory = fog_storage_service.directories.get('<Container Name>', max_keys: <Maximum No. of Keys Value>)
blob = directory.files.head('<Blob Name>')
blob.metadata = {
  Category: '<Category Value>',
  Resolution: '<Resolution Value>'
}
blob.save(update_body: <True/False>)
```

### Get Container Metadata

```ruby
directory = fog_storage_service.directories.get('<Container Name>', max_keys: <Maximum No. of Keys Value>)
puts directory.metadata
```

### Set Container Metadata

```ruby
directory = fog_storage_service.directories.get('<Container Name>', max_keys: <Maximum No. of Keys Value>)
directory.metadata = {
  CreatedBy: '<Username>',
  SourceMachine: '<Machine Name>',
  category: '<Category Value>',
  docType: '<Document Type>'
}
directory.save(is_create: <True/False>)
```

## Support and Feedback
Your feedback is appreciated! If you have specific issues with the fog ARM, you should file an issue via Github.

repository: fog/fog-azure-rm

repo_name: fog/fog-azure-rm


text:
# RESTFUL Backend for Capio Speech API

## Specs
- POST api at /transcripts
  - Accepts multipart POST requests with media files
  - Transcribes using the Capio Sync API (https://capio.readme.io/docs/transcription-rest-api)
  - Validate if uploaded file is media
  - Returns ONLY transcript text and the request ID, not the raw response
  - Results of each transcription request should be persisted (PostgreSQL) as request ID and text
- GET api at /transcripts/:id
  - Retrieve transcripts via ID
- Fully tested endpoints
- Readme
  - install dependencies
  - bootup server
  - run tests

## Capio API
To use Capio APIs, use API key “196502576af047df9864d3d05a05c785”
API endpoint - ‘https://apidev.capio.ai/v1/speech/transcribe‘

## Components
*Git* for Repo
*PostgreSQL* for persisting transcriptions
*Express* for HTTP routing
*NodeJS* for media validation
*Jasmine/Chai* for testing
*Docker* for deployment

If I have time:
*React* for front-end

## Project Quality Checklist

1. Have you read the spec VERY CAREFULLY, THREE TIMES?
2. Does this have enough tests? And does it pass the tests?
3. Does this work the way it's intended?
4. Does the git repo reflect well-managed PRs and good labeling of PRs?
5. Is 'use strict' in each file?
6. Included a .gitignore?
7. Included a .eslintrc.json?
8. Have you gone over each section with the clean code guidelines?
9. Is there one abstract 'main method' with all work delegated to other methods?
10. Does it include a Readme?
11. Does it cover weird edge cases where input is not expected?

README:
- linter
- dependencies
- code coverage badge
- function signatures
- API
- clear explanation of how it works
- continuous integration?

repository: waffle-iron/capio-api

repo_name: waffle-iron/capio-api


text:
# Developer Operations

---

- [Deployment Automation](#deployment)

## Deployment Automation

Startup Engine is built to be platform-agnostic. It can run on various open-source servers (Apache, NGINX, etc), with various open-source databases (PostgreSQL, MySQL, etc), and containerized via Docker non-containerized.

It can also be deployed to the cloud very easily via integration with [Heroku](https://devcenter.heroku.com/categories/deployment).

repository: YonatanEldan/startupengine

repo_name: YonatanEldan/startupengine


text:
# LaTeX article example

Simple LaTeX file dedicated for university assignments.

## How to use it?

1. [Install TeXLive and biber](#installation)
2. [Clone this repo to your disk](#clone)
3. [Open and compile project](#compile)
4. Have great fun :)

###  Install TeXLive and biber

**Linux**

For Debian/Ubuntu/Mint distros:

```
sudo apt-get install texlive-full biber
```

**Windows**

Install free MikTeX ([download webpage](http://miktex.org/))

###  Clone repository to your disk

**Linux**

- Use `git`
```
cd /to/your/directory/
git clone git@github.com:egel/uek-article-example.git
```

- Download manually by *download* button (on the bottom of right menu bar).

**Windows**

Download this repo by *download* button (on the bottom of right menu bar).

###  Open and compile project

Open (or install) some editor which support LaTeX (for example [Texmaker editor](http://www.xm1math.net/texmaker/download.html))

**Simple configuration of biber in Texmaker:**

> To use `biber` package need to configure Texmaker. So open Texmaker's:

> `Preferences` > `Commands`: and change Bib(la)tex field to: `biber %`

> ![Biber config](biber-config.png "Biber config")

**Set Master file:**

Open `document_main.tex` (it's a main document in this repo) and set document as root file. So open main menu: Preference > "Set current file as Master document"

**Next (in Texmaker) compile 4 times like below:**

- quick compile [F1] shortcut; This compile Master file
- quick compile [F1]
- Bibtex [F11] shortcut; Acctualy it use biber after reconfiguration
- quick compile [F1]

Have fun with this simple example :)

repository: egel/uek-latex-assignment-example

repo_name: egel/uek-latex-assignment-example


text:
![IMDB Search](https://user-images.githubusercontent.com/8599598/73617964-e46cec80-45f1-11ea-8ca6-ccea8c79d312.png)

# Movie Database Manager & Query
Currently creates a new SQL Database from IMDB datasets and allows the user to use SQL Queries on the database.

createDatabase.py allows the user to create a SQLite3 database from IMDB datasets.
useDatabase.py allows the user to search and get information from the database. Currently displays results in shell
and opens n new tabs in browsers for movies associated with the entry.

## Road Map
Greatly improve code as I learn more from about Python
For the love of god fix the lack of specified exceptions.
Implement a few other tables from other movie review sites.
Find and record movie mentions on Reddit with a list of keywords used to describe it. Weight the connotations for a "Reddit Score"
Create an interface for modifying search query.
Create a web interface to display results in a clean and reasonable manner.
Research security flaws.
Make more public.

## Installation
TODO

## Usage
Initial Usage (or to Update)
--createDatabase.py
Modify Query
--database\searchQuery.sql
Query Database
--useDatabase.py

## Contributing
Currently an independent learning project. Feel free to critique, I'm doing the project to learn by doing.

## About Me and the Project
This is the first thing I ever posted to GitHub and the first real project I have tried in Python. I'm self learning
to be a programmer to escape the construction industry. I have taken intro classes in C and Java in the past and ready to
try a new language and start making larger projects. Thanks for the read!

## License
[MIT](https://choosealicense.com/licenses/mit/)


text:
---
title: 'atomic_input_dialog/[2,3,4]'
package: ALSDev
group: Gui Library
module: alsdev
predicates:
- {sig: 'atomic_input_dialog/[2,3,4]', desc: 'input atoms and numbers'}
---

## FORMS
```
atomic_input_dialog(Msg, Input)

atomic_input_dialog(Msg, Title, Input)

atomic_input_dialog(Interp, Msg, Title, Input)
```
## DESCRIPTION

These predicates present the user with popup dialogs requesting input of text(as atoms) or numbers. The shorter versions are defined by :
```
atomic_input_dialog(Msg, Input)
    :-
    atomic_input_dialog(Msg, 'Input', Input) .

atomic_input_dialog(Msg, Title, Input)
    :-
    atomic_input_dialog(tcli, Msg, Title, Input) .
```
For the general call
```
atomic_input_dialog(Interp, Msg, Title, Input),
```
`Interp`, `Msg`, and `Title` should all be atoms, while `Input` should be an uninstantiated variable.

## EXAMPLES

The call
```
?- atomic_input_dialog('Please input something:', Input).
```
will popup the following window :

![](images/atomic_input.gif)

If the user types
```
Logic is wonderful
```
then the result would be
```
Atom = Logic is wonderful
```
## NOTES

The default Tcl interpreter for `atomic_input_dialog/[2,3,4]` is `tcli` as shown above.  This interpreter is *_NOT_* automatically initialized by alsdev.  You must first run [`init_tk_alslib/0` or `init_tk_alslib/1`, or run `init_tk_alslib/2`](init_tk_alslib.html) with `Interp = tcli`.  If you wish to run `atomic_input_dialog/4` with `Interp` bound to a Tcl interpreter `I` other than `tcli`, you must first run `init_tk_alslib/2` with `Interp` bound to this same `I` (only once is necessary).

## SEE ALSO

- [`init_tk_alslib/[0,1,2]`](init_tk_alslib.html)

repository: AppliedLogicSystems/ALSProlog

gha_language: C

repo_name: AppliedLogicSystems/ALSProlog


text:
# eopkg3p

**A drop-in replacement for `eopkg` that supports Solus 3rd party packages!**

Also ships with a Python API, as a bonus.

## Install

Just download, make executable and run!

```
$ wget https://github.com/pycampers/eopkg3p/releases/download/v0.0.6/eopkg3p
$ chmod +x ./eopkg3p
$ ./eopkg3p
```

[Releases](https://github.com/pycampers/eopkg3p/releases)

---

Or, install using `pip`

```
$ pip3 install eopkg3p
```

Python 3.6+ only
MIT Lisence

## Dependenices

- `python3.6`
- `git`
- `eopkg`
- `pkexec`

## Usage

If you know `eopkg`, you _already_ know `eopkg3p`.

```
$ eopkg3p
Usage: eopkg3p [OPTIONS] COMMAND [ARGS]...

Options:
  --cache  Output the cache dir.
  --help   Show this message and exit.

Commands:
  delete-cache    (dc) Delete cache files
  install         (it) Install packages
  list-available  (la) List all packages available in the local repository.
  list-installed  (li) List all 3rd party packages that are currently...
  remove          (rm) Alias for `eopkg rm`
  update-repo     (ur) Update the local repository
  upgrade         (up) Upgrade 3rd party packages
```

## Why?

Installing and updating 3rd party packages is a real pain from the Software center.
This package elimitates that problem.

---

## API
`eopkg3p` has a Python API as a bonus and can be imported like so:
`import eopkg3p`

#### `build_pspec(pspecfile: Path)`
Build eopkg package of a 3rd party app based on the app's pspec file from the `Path` object in the `pspecfile` argument.
`pspecfile` has to be a `Path` object.

#### `check_local_repo()`
Check that the local repository directory (`$HOME/.cache/eopkg3p/3rd-party`) exists and that it's not empty.

#### `extract_description(pspecfile: Path)`
Return the description of a 3rd party app as a string based on the app's pspec file from the `Path` object in the `pspecfile` argument.

#### `extract_latest_release(pspecfile: Path)`
Return the release number of a 3rd party app as an integer based on the app's pspec file from the `Path` object in the `pspecfile` argument.

#### `filter_installed(available: Dict[str, Path]) -> Dict[str, Path]*`
If given the argument `available` as a `dict` object with string as first argument and a `Path` object as the second argument, the function will return a dict object with only the installed 3rd party apps.

#### `filter_outdated(available: Dict[str, Path]) -> Dict[str, Path])`
If given the argument `available` as a `dict` object with string as first argument and a `Path` object as the second argument, the function will return a dict object with only the outdated 3rd party apps.

#### `get_available() -> Dict[str, Path]`
Return a `dict` with the name of the available 3rd party apps as a string as the key and the POSIX-path to their pspec.xml file as the value.

#### `get_installed_all() -> Generator[Tuple[str, int], None, None]`
Return all installed apps and their release number as a generator object.

#### `install_eopkg(eopkgfile: Path)`
Install eopkgfile with `eopkg` based on the app's pspec file from the `Path` object in the `pspecfile` argument.

#### `update_local_repo()`
Install eopkgfile from `file` with eopkg based on the pspec file.

[🐍🏕](http://www.pycampers.com/)


text:
---
title: Admin Password - Resetting or Changing
description: Admin password not working?  Try these steps.
category: troubleshooting
weight: 10
aliases:
    - /user/admin/admin_password/
---

## 1. Login and change it directly
If you are able to login to your Admin, and merely want to change your password, simply login, then go to the "Account" menu and change your password there.

## 2. Log in with another account.
If you can log in to your Zen Cart admin using another account (with Super-User privilege), please do so, and reset/modify the other admin password as needed using the [Admins > Admin Users](/user/admin_pages/admins/admin_users/) page.

## 3. Resend Password
If you can't login from another account, try using the *Resend Password* button on the admin login page.
Enter the admin email address, and wait for your new password to arrive by email.

## 4. Use phpMyAdmin
If the techniques above don't work, use phpMyAdmin to create a temporary admin user directly in the database. You must have database control to do this.
Open your phpMyAdmin (supplied by your hosting company), select your store's database, then click the "SQL" tab.  Run this query:

```
DELETE FROM admin WHERE admin_name = 'Admin';
INSERT INTO admin (admin_name, admin_email, admin_pass, admin_profile)
VALUES ('Admin', 'admin@localhost', '351683ea4e19efe34874b501fdbf9792:9b', 1);
```

**NOTE**: If you are using a prefix for your database tables, you'll naturally need to add that prefix to the table name above.  For example, if your prefix is `zc_`, you would use

`DELETE FROM zc_admin` and `INSERT INTO zc_admin` in the commands above.

> **NOTE**: If you are using a very old version of Zen Cart then the field names above may be different than your database has. See https://www.zen-cart.com/content.php?44-how-do-i-change-or-reset-my-admin-password for additional information.

You should now be able to login using the following details:

Username: Admin

Password: admin

Be sure to use proper case. ie. 'Admin' for username, not 'admin'.

You will be prompted to change the password right away.

After you log in, remember to delete this temporary admin account after creating a new one. See the [Admins > Admin Users](/user/admin_pages/admins/admin_users/) page.

repository: sitedata/documentation

repo_name: sitedata/documentation


text:
# github-contribution-writter
Script to write messages in the contribution chart

# Purpose
Be able to write arbitrary messages into Github's contribution chart, because lets face it most of the time my commit chart is just barren.

# How to
Make a script that takes in a string and path to repo. The script figures out on which days you need to make commits and makes (literal) dummy commits to make text appear.

# Spex
The commit chart is 7 by Something-wide for text to look nice let's use 5x3 letters leaving one row on top and below of a letter and one column in between.

# TODO
- [x] Figure a way to add letters
- [ ] Add all letters
- [x] Generate boolean representation of written text
- [ ] How to track days
- [ ] Figure out where to run the script
- [ ] PROFIT!

license: Unlicense

repository: totu/github-contribution-writter

repo_name: totu/github-contribution-writter


text:
# CTR DaPP
**_Concentric Tube Robot Design and Path Planning_** is an optimization algorithm for the design of concentric tube robots based on a flexible path planner.

The CTR DaPP library was developed to allow for non-constant strain initial curvatures of concentric tube robots.
The library is made up of multiple packages, each allowing for easy extension:
* **MODEL**: The mechanics of the robot, primarily offering the SE(3) g-curves for a robot given insertion and rotation values
  * Initial models follow Dr. Renda's strain-based static and kinematic models
* **COLLISION**: Provides collision queries between the model output and the environment (obstacles and goal)
  * The collision detection package utilizes the Fast Collision Library (python-fcl)
* **SOLVER**: The path planner, used to explore the environment and find a path to the goal
  * Initial path planners utilize the RRT (randomly-exploring rapid tree) sampling-based framework
* **HEURISTIC**: Defines the cost of a configuration (and path) of a robot
  * Initial heuristics use distance to goal, distance from obstacles, follow the leader path behavior
* **OPTIMIZE**: The algorithm used to optimize the design parameters (q curvature values) for a given environment
  * Initial optimizer uses nelder-mead, requiring only an initial simplex and no derivative information

Configuration files allow for specifying the environment and which package types to use (RRT vs. RRT*, static vs. kinematic, etc.).
A few pre-written scripts also allow for easy interaction with the API.

## Usage

```python
from ctrdapp.scripts.full_optimize import full_optimize

full_optimize()  # runs full optimization algorithm
```
```commandline
Enter name of configuration file (with .yaml extension):
> config.yaml
Enter initial guess for the q; should be 5 numbers long, each separated by a comma. (Tubes have these degrees of freedom: [2, 3]).
> 0.02, 0.001, 0.05, 0.0001, 0.002
```
Runs the algorithm with the specified configuration.
Outputs include the optimization process (q's and costs), the optimization summary, and the best design path planner results (full tree, solution path, and path movie).
The outputs are saved in the directory specified in the configuration file.

## Installation

Install the library from source. Python dependencies are defined in the Pipfile, except for the pympnn package which can be installed here.

## License
[MIT](https://choosealicense.com/licenses/mit/)

repository: ConorMesser/ctr-design-and-path-plan

gha_language: Python

repo_name: ConorMesser/ctr-design-and-path-plan


text:
Title: RCE 7.1
Date: 2016-05-24 15:00
Category: Releases
Author: RCE
Image: release-7.1/general.png

We recently released RCE 7.1, a new minor version with several new features and many improvements. Below is a selection of some features. Please see [GitHub](https://github.com/rcenvironment/rce/wiki/Changelog:-7.x.x-Releases) for the full changelog.

### Unified Access to Documentation in RCE

Documentation of RCE is spread over different places: component documentation is accessible from the workflow editor, documentation about tool integration is accessible from the tool integration dialog, and the user guide in PDF format. We introduced a new help system to make all of the documentation additionally accessible from one single place. Go to the menu bar under "Help -> Help Contents". A window opens with all of the documentation and nice navigation and search capabilities.

![Photo]({attach}images/release-7.1/help_system.png)

### Workflow Outline View

Workflows with many components get quite big. For keeping track of those workflows, we added a new outline view. It displays the complete workflow in a thumbnail format and highlights the area of the workflow which is currently shown in the workflow editor.

![Photo]({attach}images/release-7.1/outline_view.png)

### Enhanced Workflow Canceling

In case a workflow is canceled (by the user or after a failure in the workflow), integrated tools as well as running Python scripts (executed by the Script component) are canceled imediately. It is no longer waited until they terminate itself. Also, jobs submitted to a cluster (by the Cluster component) are canceled imediately. In case of long running tools, scripts or cluster jobs, compute time is saved now.

![Photo]({attach}images/release-7.1/canceled.png)

### Extended SSH Remote Access

RCE provides an SSH interface to execute components and workflows (among others). Next to username and password, authentication via key files is now supported. Also, when connecting an RCE client to another RCE instance via SSH, not only remotely published components can be used in workflows, but also remotely published workflows appear in the workflow component palette ready to use in workflows.

### Enhanced Workflow Components

We made enhancements to several workflow components such as:

The mapping file required by the XML Merger can be sent as an input. This makes reloading the mapping file on each change obsolete.
The Evaluation Memory can be used in fault-tolerant loops as it is now able to treat loop failures properly.
The behavior of the Converger can be defined in case convergence was not reached. Also, outputs are added which indicate convergence for every input separately.
The Output Writer supports new placeholders: "original filename" and "execution count".

repository: DLR-SC/rce-website

gha_language: CSS

repo_name: DLR-SC/rce-website


text:
[![Build Status](https://api.travis-ci.com/CarliJoy/django-pint.svg?branch=master)](https://travis-ci.com/github/CarliJoy/django-pint)
[![codecov](https://codecov.io/gh/CarliJoy/django-pint/branch/master/graph/badge.svg?token=I3M4CLILXE)](https://codecov.io/gh/CarliJoy/django-pint)
[![PyPI](https://img.shields.io/pypi/dm/django-pint.svg?maxAge=2592000?style=plastic)](https://pypi.org/project/django-pint/)
[![Python Versions](https://img.shields.io/pypi/pyversions/django-pint.svg)](https://pypi.org/project/django-pint/)
[![PyPI](https://img.shields.io/pypi/v/django-ping.svg?maxAge=2592000?style=plastic)](https://pypi.org/project/django-pint/)
[![Wheel Build](https://img.shields.io/pypi/wheel/django-pint.svg)](https://pypi.org/project/django-pint/)
[![Code Style Black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Documentation Status](https://readthedocs.org/projects/django-pint/badge/?version=latest)](https://django-pint.readthedocs.io/en/latest/?badge=latest)

# Django Quantity Field

A Small django field extension allowing you to store quantities in certain units and perform conversions easily. Uses [pint](https://github.com/hgrecco/pint) behind the scenes. Also contains a form field class and form widget that allows a user to choose alternative units to input data. The cleaned_data will output the value in the base_units defined for the field, eg: you specify you want to store a value in grams but will allow users to input either grams or ounces.

## Compatibility

Requires django >= 2.2, and python 3.6/3.7/3.8/3.9

## Installation

    pip install django-pint

## Simple Example

Best way to illustrate is with an example

    # app/models.py

    from django.db import models
    from quantityfield.fields import QuantityField

    class HayBale(models.Model):
	    weight = QuantityField('tonne')

Quantities are stored as float (Django FloatField) and retrieved like any other field

    >> bale = HayBale.objects.create(weight=1.2)
    >> bale = HayBale.objects.first()
	>> bale.weight
	<Quantity(1.2, 'tonne')>
	>> bale.weight.magnitude
	1.2
	>> bale.weight.units
	'tonne'
	>> bale.weight.to('kilogram')
	<Quantity(1200, 'kilogram')>
	>> bale.weight.to('pound')
	<Quantity(2645.55, 'pound')>

If your base unit is atomic (i.e. can be represented by an integer), you may also use `IntegerQuantityField` and `BigIntegerQuantityField`.

You can also pass Quantity objects to be stored in models. These are automatically converted to the units defined for the field ( but can be converted to something else when retrieved of course ).

    >> from quantityfield.units import ureg
    >> Quantity = ureg.Quantity
    >> pounds = Quantity(500 * ureg.pound)
    >> bale = HayBale.objects.create(weight=pounds)
    >> bale.weight
    <Quantity(0.226796, 'tonne')>

Use the inbuilt form field and widget to allow input of quantity values in different units

    from quantityfield.fields import QuantityFormField

    class HayBaleForm(forms.Form):
        weight = QuantityFormField(base_units='gram', unit_choices=['gram', 'ounce', 'milligram'])

The form will render a float input and a select widget to choose the units.
Whenever cleaned_data is presented from the above form the weight field value will be a
Quantity with the units set to grams (values are converted from the units input by the user ).
You also can add the `unit_choices` directly to the `ModelField`. It will be propagated
correctly.

For comparative lookups, query values will be coerced into the correct units when comparing values,
this means that comparing 1 ounce to 1 tonne should yield the correct results.

    less_than_a_tonne = HayBale.objects.filter(weight__lt=Quantity(2000 * ureg.pound))

You can also use a custom Pint unit registry in your project `settings.py`

    # project/settings.py

    from pint import UnitRegistry

    # django-pint will set the DJANGO_PINT_UNIT_REGISTER automatically
    # as application_registry
    DJANGO_PINT_UNIT_REGISTER = UnitRegistry('your_units.txt')
    DJANGO_PINT_UNIT_REGISTER.define('beer_bootle_weight = 0.8 * kg = beer')

    # app/models.py

    class HayBale(models.Model):
        # now you can use your custom units in your models
        custom_unit = QuantityField('beer')

Note: As the [documentation from pint](https://pint.readthedocs.io/en/latest/tutorial.html#using-pint-in-your-projects)
states quite clearly: For each project there should be only one unit registry.
Please note that if you change the unit registry for an already created project with
data in a database, you could invalidate your data! So be sure you know what you are
doing!
Still only adding units should be okay.

repository: cornelv/django-pint

repo_name: cornelv/django-pint


text:
# Linked Data Fragments Server - Summary
<img src="http://linkeddatafragments.org/images/logo.svg" width="200" align="right" alt="" />

[![npm version](https://badge.fury.io/js/%40ldf%2Ffeature-summary.svg)](https://www.npmjs.com/package/@ldf/feature-summary)

This module adds summaries to datasources based on turtle files corresponding to the datasource name.

_This package is a [Linked Data Fragments Server module](https://github.com/LinkedDataFragments/Server.js/)._

## Usage in `@ldf/server`

This package exposes the following config entries:
* `SummaryController`: Responds to requests for summaries. This is enabled by default in `@ldf/server`. _Should be used as `@type` value._
* `SummaryQpfHtmlView`: Extends the Quad Pattern Fragments HTML view with a summary link. This is enabled by default in `@ldf/server`. _Should be used as `@type` value._
* `SummaryQpfRdfView`: Extends the Quad Pattern Fragments RDF view with a summary link. This is enabled by default in `@ldf/server`. _Should be used as `@type` value._
* `SummaryRdfView`: Represents a data summary in RDF. This is enabled by default in `@ldf/server`. _Should be used as `@type` value._
* `summaryDir`: Path to a directory where summaries can be found. _Should be used as key in a `Server` config or `SummaryController`._
* `summaryPath`: URL path for summaries. _Should be used as key in a `Server` config or `SummaryController`._

`@ldf/server` and `@ldf/preset-qpf` provide default instantiations of `SummaryController`, `SummaryQpfHtmlView`, `SummaryQpfRdfView` and `SummaryRdfView`,
which means that you don't have to define them in your config file yourself.
The only thing you still need to do is defining the summary directory and the URL on which they should be exposed, as shown in the example below.

Example:
```json
{
  "@context": <EMAIL_ADDRESS>  "@id": "urn:ldf-server:my",
  "import": "preset-qpf:config-defaults.json",

  "summaryDir": "../../summaries",
  "summaryPath": "/summaries/"
}

```

## Usage in other packages

When this module is used in a package other than `@ldf/server`,
then the JSON-LD context<EMAIL_ADDRESS>must be imported.

For example:
```
{
  "@context": [
<EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS>  ],
  "@id": "urn:ldf-server:my",

  "controllers": [
    {
      "@id": "urn:ldf-server:mySummaryController",
      "@type": "SummaryController"
    }
  ],

  "views": [
    {
      "@id": "urn:ldf-server:myQpfHtmlView", // This should refer to your existing QpfHtmlView
      "viewExtension": {
        "@id": "urn:ldf-server:mySummaryQpfHtmlView",
        "@type": "SummaryQpfHtmlView"
      }
    },
    {
      "@id": "urn:ldf-server:myQpfRdfView", // This should refer to your existing QpfRdfView
      "viewExtension": {
        "@id": "urn:ldf-server:mySummaryQpfRdfView",
        "@type": "SummaryQpfRdfView"
      }
    },
    {
      "@id": "urn:ldf-server:mySummaryRdfView",
      "@type": "SummaryRdfView"
    }
  ]

  // Same as above...
}
```

## License
The Linked Data Fragments server is written by [Ruben Verborgh](https://ruben.verborgh.org/), Miel Vander Sande, [Ruben Taelman](https://www.rubensworks.net/) and colleagues.

This code is copyrighted by [Ghent University – imec](http://idlab.ugent.be/)
and released under the [MIT license](http://opensource.org/licenses/MIT).

gha_language: JavaScript

gha_license_id: NOASSERTION


text:
# Portfolio Project

This in my second official project as a Micronaut (Microverse Student). This repository was created to showcase new skills that I have learnt.
This project was extremely challenging for me. Though, it enabled me to learn many new skills.

### The project concerntrates on the following topics:
* Working with a UI/UX Design Tool (I was able to parse a Figma design to create a UI for the first time).
* Working with Flexbox assist in placing elements in the page.
* Building a personal portfolio site.
* Using images and backgrounds to enhance the look of the website.

### Project Visual:
![Screenshot 2021-10-22 at 2 28 45 PM](https://user-images.githubusercontent.com/74268053/138505974-316b8dfd-8be4-4c4c-bb91-ab50e14954c3.png)

### Built With:
Languages
* HTML & CSS

IDE
* Visual Studio Code

UI/UX Design Tool
* Figma

Command Line
* Bash (Mac)

### Author:
👤 Toni Davis-Bonaparte (Tonz)

* GitHub: @tonzthegr8est
* LinkedIn: [Toni T. Davis-Bonaparte](https://www.linkedin.com/in/toni-t-davis-bonaparte-a31883126/)
* Twitter: @tonzthegr8est

### 📝 License
This project is [MIT](https://github.com/tonzthegr8est/my-portfolio/blob/main/LICENSE) licensed.


text:
---
layout: post
title:  "Gullship"
date:   2018-05-03
sources: [TCToS.63]
tags: [bard, sorcerer, level7, transmutation, ritual]
---

**7th-level transmutation (ritual)**

**Casting Time**: 10 minutes

**Range**: Touch

**Components**: V, S, M (a model boat and the feather of a seagull)

**Duration**: 12 hours

One boat you touch that is no more than 100 feet long gains the ability to fly. You can control the vessel’s altitude up, and can cause it to rise to no more than 500 feet in the air. The vessel is still dependant on the winds to move forward, however.

When the spell ends, the ship gently lowers itself to ground or sea level.

repository: JohanSpaedtke/grimoire

extension: markdown

repo_name: JohanSpaedtke/grimoire


text:
This project is  my final assignment to take the degree of facilities at Ahmad Dahlan University [paper].
This application is useful for providing sentiment info on comments and posts in blog posts (wordpress).
in this project the method what i use to classify comment to positive, neutral or negative is K-Nearest Neighbour (KNN), you can check step by step POC the method in https://informatikalogi.com/

### Required:
- python (2.7 or higher)
- wordpress

### How to use this app
1. Restfull API
- extract RestAPI_python.zip
- run on pyhton with this script "python app.py" in your extract folder
- if error. There are no modules needed such as literature, flask etc., install first ex: pip install flask
- if other error such as python version maybe you can edit some code to your oython version, cause in this code i'm still use python 2.7

2. Wordpress
- install the plugin with wordpress (open TAnalyzer.zip)
- enable plugin (after restAPII running)
- if want to use my data comment, please import my database.db / my database.sql with phmyadmin
- the base plugin here is hercules sentiment analyzer, i just edit little bit for showing sentiment from my python restAPI. this Hercules Sentiment analyzer is cool plugin :D

Congratulation \ (^ o ^) /

if any question please mail me on <a href="mailto: dwipurwanto.210<EMAIL_ADDRESS>| Telegram  Dwi Purwanto

repository: dwpr/Wordpress-Sentiment

repo_name: dwpr/Wordpress-Sentiment


text:
# Asana Github PR Webhook

[![CircleCI](https://circleci.com/gh/codeallthethingz/asana-github-pr-webhook/tree/master.svg?style=svg)](https://circleci.com/gh/codeallthethingz/asana-github-pr-webhook/tree/master)
[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)
[![codecov](https://codecov.io/gh/codeallthethingz/asana-github-pr-webhook/branch/master/graph/badge.svg)](https://codecov.io/gh/codeallthethingz/asana-github-pr-webhook)

## Updates from codeallthethingz's original repo

- [x] Get asana task ID from PR description instead of 4 digits
- [x] Use Vercel's environment variables

Links a PR in asana when a new Pull Request is created in Github with the task url in the description.

## Usage

Include a link to the asana ticket in the PR description. The last segment of the URL will be used to find the task:

```
# PR description example
Fix things. See [Asana Task](https://app.asana.com/1/2)
```

See a link to the PR appear as a comment on that task in Asana.

See a link to the Asana task appear as a comment on the PR.

## Installation

### 1. Get an Asana access token

- To get an [access token](https://app.asana.com/0/developer-console) go to 'My Profile Settings' -> Apps -> 'Manage Developer Apps' -> 'Create new personal access token'.
- Make a note of the access token as you'll need it later on. `<asana access token>`

### 2. Get your Asana workspace id

- Make sure you're logged in to asana and go to `https://app.asana.com/api/1.0/workspaces`
- Make a note of the gid as you'll need it later on. `<workspace id>`

### 3. Get an Github access token

- To get an access token go to 'Settings' -> 'Developer Settings' -> 'Personal Access Token' -> 'Generate new token'.
- Under 'scopes' select 'Repo'.
- Make a note of the access token as you'll need it later on. `<github access token>`

### 4. Deploy the application

This project uses [Vercel](https://vercel.com/) to deploy, which requires only a github account and gives you unlimited free invocations a month.

- Create a long, random password that we'll refer to as `<webhook secret>`
- Fork this repo and download it.
- Change the `now.json` config to choose a different alias as you won't be able to use the default.  We'll refer to this URL as `<url>`
- Run `npm install`
- Run
    ```bash
    vercel --prod \
      -e WEBHOOK_SECRET="<webhook secret>" \
      -e ASANA_ACCESS_TOKEN="<asana access token from step 1>"\
      -e WORKSPACE_ID="<workspace id from step 2>"\
      -e GITHUB_ACCESS_TOKEN="<github access token from step 3>"
    ```
- Go to vercel.com -> asana-github-pr-webhook project -> Settings -> Domains to retrieve a non-changing URL for step 5

### 5. Setup webhooks in Github

- For the github project you want to integrate, go to settings -> webhooks -> add a new webhook.
- Set the Payload URL to `https://<url from step 4>/webhook.js`
- Set the content type to `application/json`
- Set the secret to `<webhook secret>`
- Set the events to 'Let me select individual events' and check the box next to 'Pull Requests'
- Save.

Everything should work.

## Contributing

### Folder structure
```
src/
  asana.js      # Client for querying asana through asanator
  asanator.js   # Interface over asana APIs
  github.js     # Client for querying github through githubator
  githubator.js # Interface over github APIs
  processor.js  # Glue github and asana clients together
webhook.js    # Process requests incoming from github
```

### Useful Commands
```
npm      # Install dependencies
npm test # Run tests
```

repository: IliasDeros/asana-github-pr-webhook

repo_name: IliasDeros/asana-github-pr-webhook


text:
# Learning Shared Vertex Representation in Heterogeneous Graphs with Convolutional Networks for Recommendation

```
@inproceedings{pgcn_ijcai19,
  title     = {Learning Shared Vertex Representation in Heterogeneous Graphs with Convolutional Networks for Recommendation},
  author    = {Xu, Yanan and Zhu, Yanmin and Shen, Yanyan and Yu, Jiadi},
  booktitle = {Proceedings of the Twenty-Eighth International Joint Conference on Artificial Intelligence (IJCAI)},
  pages     = {4620--4626},
  year      = {2019}
}
```

links
- [ijcai](https://www.ijcai.org/proceedings/2019/642)

gha_language: Jupyter Notebook


text:
# aks-cncf-poc

This repository is created for discover some technology around k8s & the CNCF
## Getting Started

### Prerequisites

What things you need to install the software and how to install them :

- Terraform ([Docker](https://hub.docker.com/r/hashicorp/terraform/), [install](https://www.terraform.io/downloads.html))

It is also necessary to have an Azure account :
- Azure account ([Free here](https://azure.microsoft.com/fr-fr/free/))
## Running the tests

For validate terraform project configuration, it's possible to run :
```
terraform validate [options] [dir]
```

### Installing

Run a previously of infrastructure build

```
terraform plan
```

Apply or create the new infrastructure

```
terraform apply
```

## Built / deploy

* [Azure DevOps](https://azure.microsoft.com/fr-fr/services/devops/) - DevOps tools (CI/CD) by [Microsoft](https://www.microsoft.com/fr-fr/)
* [Terraform](https://www.terraform.io/) - IaC tool by [HashiCorp](https://www.hashicorp.com/)

## Versioning

We use [SemVer](http://semver.org/) for versioning. For the versions available, see the [tags on this repository](https://github.com/yfouillet/aks-cncf-poc/tags).

## Authors

* **Yoann Fouillet** - *Initial work*

See also the list of [contributors](https://github.com/yfouillet/aks-cncf-poc/graphs/contributors) who participated in this project.

## License

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

## Acknowledgments

* [Julien Landuré](https://github.com/jlandure) - For introducing me to the CNCF environment

repository: yfouillet/aks-cncf-poc

repo_name: yfouillet/aks-cncf-poc


text:
---
title: DependencyProperty<T>
parent: Types
grand_parent: API
nav_order: 43
---

# DependencyProperty<T>

## Description

Dependency property. A dependency property manages the property values of dependency objects (views). Contains information about a property, its default values, various states, and property changed handlers attached.