text:
---
title: Delphi Research Group
linkTitle: About Delphi
layout: about

collaborators:
- name: Amazon
  group: collaborator
- name: Centers for Disease Control and Prevention
  group: collaborator
- name: Change Healthcare
  group: collaborator
- name: Defense Threat Reduction Agency
  group: collaborator
- name: Facebook
  group: collaborator
- name: Google
  group: collaborator
- name: Google.org
  group: collaborator
- name: Optum
  group: collaborator
- name: Quidel Inc.
  group: collaborator
- name: Uptake
  group: collaborator

---

### Who are we?

We're a research group based out of Carnegie Mellon University dedicated to developing the theory and practice of epidemic tracking and forecasting. Pre-pandemic we worked mostly on influenza, dengue and norovirus; we've now picked up a focus on COVID. We procure unique data streams that reflect epidemic (or pandemic) activity, extract relevant indicators, and make these publicly and continuously available. We and others then use these indicators for nowcasting (situational awareness) and short-term forecasting.

### Who is our audience?

Public health authorities (federal, state, local), the healthcare industry, the public and private sectors, fellow researchers working on epidemic tracking and forecasting, data journalists, and the general public.

### Delphi's milestones

In reverse chronological order.

- **April 2020.** We began supporting and advising the U.S. CDC's
  community-driven COVID-19 forecasting effort, including creating and
  maintaining an ensemble forecast from the models submitted to the
  [COVID-19 Forecast Hub](https://covid19forecasthub.org), and a [forecast
  evaluation dashboard](https://delphi.cmu.edu/forecast-eval/).

- **March 2020.** We launched [COVIDcast]({{< relref "covidcast" >}}), the
  nation's largest public repository of diverse, real-time indicators of
  COVID-19 activity, freely accessible through the [Epidata API]({{< apiref
  "api/covidcast.html" >}}), which is updated daily with the latest data.

- **2019.** We became a CDC National Center of Excellence for Influenza
  Forecasting, one of two nationally (and a 5-year designation).

- **2016.** We developed and deployed
  [influenza nowcasts](https://delphi.cmu.edu/nowcast/) for the CDC, state
  departments of public health, and the public.

- **2016.** We developed and deployed the [Epidata API]({{< apiref "/" >}}),
  which provides real-time access to epidemiological surveillance data.

- **2013.** We began supporting the U.S. CDC's Influenza Division in advancing
  and growing a [scientific community around influenza
  forecasting](https://www.cdc.gov/flu/weekly/flusight/index.html). We've been
  [perennial leaders in forecasting
  accuracy](https://www.cs.cmu.edu/~roni/CDC%20Flu%20Challenge%202014-2018%20Results.pdf)
  ever since.

repository: cmu-delphi/www-main

branch_name: refs/heads/dev

repo_name: cmu-delphi/www-main


text:
# interactors-dotnetcore

Interactor pattern and helpers in ASP.NET Core.

---

## Setup

#### Built With

- ASP.NET Core 2.2

---

## Intent

#### Application Services

The interactor is a service object. It constrains the service object to a single business need/responsibilty. The concept here is to pass in a request from say your controller or an interactor coordinator, and then it handles the flow of logic for that unit of logic.

#### Interactor Structure/Style

The interactor service object houses a single business need, therefor they should have a single publicly accessable entry point. Their dependencies needed to perform the logic are passed in and it returns a shared contract that can be reasoned about in the system's layers above.

Interactor Contract
```
public interface IInteractor<TResult, TRequest>
    where TResult : class
{
    InteractorResult<TResult> Call(TRequest request);
}
```

Example Contract
```
public interface ICreateMonsterInteractor
    : IInteractor<Monster, CreateMonsterRequest> {}
```

Interactor Implementation
```
public InteractorResult<Monster> Call(CreateMonsterRequest request)
{
    return PerformCall(() =>
    {
        var monster = _monsterFactory.For(request);

        var monsterValidation = monster.Validate();
        if(!monsterValidation.IsValid)
            return InteractorResult<Monster>.ForFailure(monsterValidation.Messages);

        var result = _monsterRepository.Add(monster);
        return InteractorResult<Monster>.ForSuccess(result);
    });
}
```

In this system we are stating that the Interactors are safe to call and handle exceptions. See this PerformCall inline delegate caller implementation:
```
protected InteractorResult<T> PerformCall<T>(Func<InteractorResult<T>> performCall)
    where T : class
{
    try
    {
        return performCall();
    }
    catch (Exception e)
    {
        return InteractorResult<T>.ForFailure(e);
    }
}
```

#### Interactor Coordniators

Eventually you will want to chain a series of interactors together to form a larger 'process'. In such cases, an Interactor Coordinator with the same style of use Result Call(Request) would be created to wrap the coordination of and between the interactors it wraps to create a larger business need/case.

```
ex. playerDefeatedByMonsterInteractor

Would call and coordinate the following interactors:
    defeatPlayerInterator
    levelupMonsterInteractor
    monsterScoresPlayerDefeatInteractor
```

license: MIT

repository: backpack-o-stuff/interactors-dotnetcore

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: backpack-o-stuff/interactors-dotnetcore


text:
## CrazyRockets
[![License](https://img.shields.io/badge/Docs-hmsguides-brightgreen)](https://developer.huawei.com/consumer/en/doc/development/HMS-Guides/ml-introduction-4)

English | [中文](https://github.com/HMS-Core/hms-ml-demo/blob/master/ApplicationCases/CrazyRockets/README_ZH.md)

## Directory

* [Introduction](#introduction)
* [Project directory structure](#project-directory-structure)
* [More Scenarios](#more-scenarios)
* [Procedure](#procedure)
* [Supported Environments](#supported-environments)
* [License] (#license)

## Introduction
CrazyRockets uses the facial recognition and gesture recognition functions of Huawei ML Kit to move small rockets to avoid obstacles.

This demo demonstrates how to use [HUAWEI ML Kit](https://developer.huawei.com/consumer/cn/hms/huawei-mlkit) to quickly develop Crazy Rocket applications. The purpose is to experience facial recognition and gesture recognition, helping you integrate HUAWEI ML Kit as soon as possible.

## Project directory structure
BeautyCamera
    |-- com.huawei.mlkit.sample
        |-- Activity
            |-- MainActivity // entry
            |-- FaceGameActivity // Facial recognition
            |-- HandGameActivity // Gesture recognition

## More Scenarios
With the face recognition capability and gesture recognition capability provided by HUAWEI ML Kit, you can not only develop CrazyRockets applets, but also implement various functions, such as:
1. Gesture capture.
2. Smile capture.

## Procedure
- Preparations
  - Add the Huawei Maven repository to the build.gradle file in the root directory of the project.
  - Add build dependency on the SDK to the build.gradle file in the app directory.
  - Add the face detection model to the manifest.xml file of Android.
  - Apply for the camera permission in the manifest.xml file of Android.

- Key steps of code development
  - Submit a dynamic permission application.
  - Create a skeleton analyzer.
  - Create a LensEngine.
  - Call the lensEngine.run(holder) method to perform CrazyRockets.

For details about the development procedure, see [Crazy Rockets - How to Integrate Face Detection and Gesture Recognition with Huawei HMS ML Kit to Create a Hilarious Game](https://forums.developer.huawei.com/forumPortal/en/topic/0203394887034330038?fid=0101187876626530001?ha_source=hms1).

## Supported Environments
Devices with Android 4.4 or later are recommended.

##  License
The face detection sample of HUAWEI ML Kit has obtained the [Apache 2.0 license](http://www.apache.org/licenses/LICENSE-2.0).

repository: glovebx/hms-ml-demo

repo_name: glovebx/hms-ml-demo


text:
# Check Ready

This section describes the `checkReady` task available to use in the deployment strategies (`kegd.yaml` file).

Example:
```
compose:
  - name: Create
    deploy:
      - objects:
          file: my-deployment.yaml
    checkReady:
      script: ready.py
```

## Arguments

### script

| Mandatory | Default | Templated Value |
| --- | --- | --- |
| Y | - | N |

The file, from the `Lifecycle/kubernetes/scripts` directory of your Resource package, to use as a check ready script. This script must use Python syntax and must include the following `checkReady` function, with your desired implementation:

```python
def checkReady(keg, props, resultBuilder, log, *args, **kwargs):
    # Do the check here
    pass
```

This function is called by the driver to perform the ready check. The arguments to this function are as follows:

| Name | Description |
| --- | --- |
| keg | A collection of all the objects/helm releases deployed as part of this Resource (only those that still exist, so any objects that have been removed by a transition are not included) |
| props | A dictionary of all the properties available for this Resource. These are the same properties used when rendering templates |
| resultBuilder | Helper object for managing the result of the ready check |
| log | Utility to log messages to (see more later) |
| *args and **kwargs | Python constructs for consuming any additional arguments passed to this function. You won't need to use them, so they are not required but it is highly recommended, as it will keep your scripts compatible with later versions of the driver if new arguments are added to this interface |

To walk through the creation of this file, see the [Ready Checks](../user-guide/ready-checks.md) section of the user guide.

### maxAttempts

| Mandatory | Default | Templated Value |
| --- | --- | --- |
| N | - | `kegd.ready_checks.default_max_attempts` property value of the driver application (default is `10`) | N |

The maximum times the `checkReady` function is called before cancelling the transition and marking it as failed. This value should be a valid `int`. Special values include:

- `0` - no maximum attempts. Try only once.
- `-1` (or any negative value) - no limit to the attempts

There are no guarantees to how many times the check will be attempted, as the task is placed in a queue and may be dequeued at any time based on load.

### timeoutSeconds

| Mandatory | Default | Templated Value |
| --- | --- | --- |
| N | - | `kegd.ready_checks.default_timeout_seconds` property value of the driver application (default is `300`) | N |

The amount of time that may pass, since the first ready check attempt, before the task is considered expired and the transition is marked as failed.

This value should be a valid `int` and never `0` or below. The value should also stay below the configured `kegd.ready_checks.max_timeout_seconds` on the driver. If it exceeds this, the value of `max_timeout_seconds` is used instead.

There are no guarantees the task will expire exactly after this time has passed, as the task is placed in a queue and may be dequeued at any time based on load. However, on dequeue, this value is checked and the next attempt is cancelled and no future attempts will be made.

### intervalSeconds

| Mandatory | Default | Templated Value |
| --- | --- | --- |
| N | - | `kegd.ready_checks.default_interval_seconds` property value of the driver application (default is `5`) | N |

The amount of time that must pass before the next attempt. This is only a minimum, the next attempt may occur any time after this.

This value should be a valid `int` and '0' or below will result in no interval (although there will be an unknown interval based on load, as the task is queued and dequeued)

repository: Pafcuenca/kubernetes-driver

repo_name: Pafcuenca/kubernetes-driver


text:
Code used during the AWS IoT talk "Derive insights from IoT in minutes on AWS"

Slides: https://www.slideshare.net/hornsby/derive-insight-from-iot-data-in-minute-with-aws-73773075

**Goal**:
Connect the RaspberryPi with SenseHat to the AWS IoT platform using MQTT protocol and test real-time interaction between the RaspberryPi and the IoT platform.

The mqtt-sub application launches 2 subroutines:
- one publisher sending the data from the temperature sensor of the RaspberryPi Senshat device (publish_topic)
- one subscriber that listened to a topic (subscribe_topic) and that prints out the message received from that topic to the screen of the Sensorhat device.

![Demo](https://github.com/adhorn/rasp-sensehat-iot/blob/master/pics/demo2.png)

**AWS IoT** easily and securely connects devices through the MQTT and HTTPS protocols. The IoT Rules Engine continuously processes incoming messages, enabling your devices to interact with other AWS services.

**MQTT** is a bi-directional protocol [...]

**Prerequisites:**

* Create an IoT "Thing" and download the certificate bundle and unzip the file onto the RaspberryPI. Update the file path of those file in the file ```default_settings.py``` or in a file called ```settings.py````.
Update also the AWS_IOT_ENDPOINT with the endpoint of your IoT "Thing"

* Install the dependencies in ```pip install -r requirements.txt```

* Run the application ```python mqtyt-sub.py```

* In the AWS Console IoT service, select your "Thing" and click "Interact" and "start MQTT"

* Subscribe to the topic "$aws/things/sensehat/shadow/update/temperature" and you should see the temperatures updating from the RaspberryPi.

* Click Publish and select "$aws/things/sensehat/shadow/update/info/test"
(the # is a wildcard) - type any message (e.g Hello Folks!)
You should see in the mqtt-sub.py logging (screen prints) that the RaspberryPi received the message and you should also see that message displayed on the display of the Sensorhat device.

repository: adhorn/rasp-sensehat-iot

gha_language: Python

gha_license_id: MIT

repo_name: adhorn/rasp-sensehat-iot


text:
# Container for F# as a build step on gcloud

See [docs](https://cloud.google.com/cloud-build/docs/concepts/custom-build-steps)

## Usage:

```
steps:
- name: gcr.io/$PROJECT_ID/fsharp
  id: fsharp-version
  args: ['fsharpc', '--help']
- name: gcr.io/$PROJECT_ID/fsharp
  id: fsharp-build
  args: ['msbuild', '/p:Configuration=Release', 'src/App.sln']
```

## Read mode

This build tool is based on the [official F# docker container][fo]. You can
browse its README for details on what's included.

 [fo]: https://github.com/fsprojects/docker-fsharp

gha_language: Go


text:
+++
author = ["Matt Layher"]
date = "2016-12-08T08:00:00+00:00"
title = "Contributing to the Go project"
series = ["Advent 2016"]
+++

Contributing to the Go project can seem overwhelming, especially at first.
The official [Contribution Guidelines](https://golang.org/doc/contribute.html)
document is rather lengthy, but after working through the initial Google CLA
and Gerrit authentication process, it becomes much easier to contribute to
the project.

This post will attempt to demystify the process behind contributing to the
Go project, in an effort to encourage all Gophers to try to tackle an issue
or solve a bug upstream for the benefit of others.

Please note: this post attempts to simplify the steps laid out in the
official Go [Contribution Guidelines](https://golang.org/doc/contribute.html)
document, but it is entirely possible that it may contain incorrect information
or become outdated over time.  When in doubt, refer to the Contribution
Guidelines or consult one of the [many help forums](https://golang.org/help/)
available for Go.

## Gerrit Registration and Google CLA

The Go project uses a system called [Gerrit](https://www.gerritcodereview.com/)
for code review.  Gerrit is where CLs (change lists; akin to a GitHub pull
request) are reviewed and submitted for inclusion in the upstream Go
repositories.

To authenticate to Gerrit, a Google account must be used.  Visit
[go.googlesource.com](https://go.googlesource.com/), click "Generate Password"
on the top right menu, and follow the instructions.  Take note of the Google
account selected, as it must be used for all remaining steps.

Next, [register with Gerrit](https://go-review.googlesource.com/login/) using
the same Google account previously selected.

Finally, you (or your organization) must agree to a Google Contributor
License Agreement (CLA).  If you are the copyright holder for your contributions,
you must agree to the
[individual CLA](https://developers.google.com/open-source/cla/individual).

If your organization is the copyright holder for your contributions, your
organization must agree to the [corporate CLA](https://developers.google.com/open-source/cla/corporate).

## git-codereview setup

It is recommended to install the `git-codereview` tool to simplify the
contribution process.  This tool is not strictly necessary, but this guide
will assume that you are using it to submit your contributions.

```
$ go get -u golang.org/x/review/git-codereview
```

Once `git-codereview` is installed, it is recommended to set up aliases for
its commands in your Git configuration file (typically `~/.gitconfig`).
This guide will also assume that these aliases are in place.

```
[alias]
	change = codereview change
	gofmt = codereview gofmt
	mail = codereview mail
	pending = codereview pending
	submit = codereview submit
	sync = codereview sync
```

## Finding an issue to work on

With the previous steps completed, you are now ready to begin contributing to
the Go project.  To find an issue to work on, browse through the
[Go issue tracker](https://golang.org/issues).  Specifically, searching for
["open" issues with the "HelpWanted" label](https://github.com/golang/go/issues?q=is%3Aopen+is%3Aissue+label%3AHelpWanted)
can be a great starting point.

Once you've found an issue you'd like to work on, leave a comment stating
that you'd like to look into solving an issue.  This helps prevent
duplication of work due to lack of communication.

There are many different repositories that belong under the Go project
umbrella, in addition to the main "go" repository.  Visit
[go.googlesource.com](https://go.googlesource.com/) to browse a list of
all available repositories.

For purposes of demonstration, we will clone the "go" repository, containing
the `go` tool, standard library, and runtime.

```
$ git clone https://go.googlesource.com/go
```

## Making a contribution

Before making any changes, it is a good idea to sync your local repository
with the upstream repository.

```
$ git sync
```

Begin working on your change.  Remember to always use tools like `go fmt`
and `go vet` on your code, and try to follow the conventions already in
place in code you are working on.

Once your change is complete (and tests have been written!), run tests
for the entire tree to ensure your changes don't break other packages
or programs.

```
$ cd go/src
$ ./all.bash
```

When `all.bash` completes, it should print the output `ALL TESTS PASSED`.
At this point, you are ready to submit your change for review.

  When ready to submit your changes, think of a meaningful branch
name and run:

```
$ git change <branch>
```

This will open a commit message file in your editor (using `$EDITOR`).

There are some conventions that should be followed for commit messages,
including:

- commit message should be prefixed with package name
- a one-line summary of the change
- if needed, a detailed description of the change (written in complete
sentences with proper punctuation)
- the phrase "Fixes ###", where ### is the Go issue you are resolving

An example of a commit message in this style, from the Contribution
Guidelines:

```
math: improve Sin, Cos and Tan precision for very large arguments

The existing implementation has poor numerical properties for
large arguments, so use the McGillicutty algorithm to improve
accuracy above 1e10.

The algorithm is described at http://wikipedia.org/wiki/McGillicutty_Algorithm

Fixes #159
```

If you wish to make further changes, use normal `git` commands and
just run `git change` again to amend your commit.  It is very common that
a given code review will often go through several rounds of feedback and
requested changes.  Don't be intimidated when asked to make changes
to your contribution!

Finally, submit your change to Gerrit by running:

```
$ git mail
```

The output of `git mail` will print a link to where your change can be
found, such as:

```
remote: New Changes:
remote:   https://go-review.googlesource.com/99999 math: improved Sin, Cos and Tan precision for very large arguments
```

## Gerrit code review

Now that your change has been submitted, it can be reviewed by a member
of the Go team and others in the community.  Code review comments may
be addressed by amending your changes using the process above.

In addition, this is the stage where the "TryBots" are run, by assigning
the label `Run-TryBot +1`.  This starts an automated testing process which
builds your change against the entire Go tree using a multitude of
different operating systems and CPU architectures.

At this point, any number of actions can take place with your change.
Typically, a member of the Go team will comment with a `Code-Review`
label, which can be interpreted as follows:

- `-2`: I am strongly against this change and will almost certainly not
be persuaded otherwise
- `-1`: I disagree with this change, but could be persuaded otherwise
- `+1`: this change looks good to me, but someone else must approve
- `+2`: this change looks good to me, and is ready for submission once
the TryBots indicate a change is OK

Depending on the `Code-Review` label applied and the ensuing discussion,
your change may or may not be accepted into the project.

In particular, if you submit a change with no issue filed and no
discussion beforehand, you can be almost certain it will be rejected.

## Summary

In summary, contributing to the Go project can be intimidating, but is
an excellent way to give back to the Go community and to gain experience
working on a large open source project, used by thousands of people all
over the world.

If your first change is rejected, be polite and ask for clarification
on why, if needed.  If you disagree with a comment, state your case concisely
and make sure that no misunderstandings take place.

If you have any questions or would like to hear about my own experiences
contributing to the Go project, feel free to contact me: "mdlayher" on
[Gophers Slack](https://gophers.slack.com/)!

repository: gopheracademy/gopheracademy-web

gha_language: CSS

gha_license_id: NOASSERTION

repo_name: gopheracademy/gopheracademy-web


text:
# node-typescript-mocha
A guide to help you create a development environment with Node, TypeScript, Mocha, and ESLint.

## Install
```
yarn install
```

## Develop
```
yarn dev
```

## Test
```
yarn test
yarn test --watch=false
```

## Build
```
yarn build
```

## Production
```
yarn start
```

branch_name: refs/heads/main


text:
# QuickSubmit

[![Build Status](https://travis-ci.org/MITLibraries/QuickSubmit.svg)](https://travis-ci.org/MITLibraries/QuickSubmit)
[![Dependency Status](https://gemnasium.com/MITLibraries/QuickSubmit.svg)](https://gemnasium.com/MITLibraries/QuickSubmit)
[![Code Climate](https://codeclimate.com/github/MITLibraries/QuickSubmit/badges/gpa.svg)](https://codeclimate.com/github/MITLibraries/QuickSubmit)
[![Coverage Status](https://coveralls.io/repos/github/MITLibraries/QuickSubmit/badge.svg?branch=master)](https://coveralls.io/github/MITLibraries/QuickSubmit?branch=master)
[![Documentation](https://img.shields.io/badge/documentation--blue.svg)](http://www.rubydoc.info/github/MITLibraries/QuickSubmit)

## What is this?

QuickSubmit is a brief web form where users can upload an article along with
sparse metadata. This will be transformed into METS and then SWORD and
submitted to an Institutional Repository (tested only with DSpace). The
primary purpose is to provide a simple upload experience with an end result of
providing a persistent URL to the submitter that they can use to show compliance
with any federal funder mandates.

The Sword packages are submitted asynchronously to provide a better user
experience. However, deploying on Heroku does not provide access to the
filesystem of the web worker from the background job worker, therefore the
attached files are stored temporarily on AWS S3. They are removed when the
QuickSubmit record is deleted. This can be scheduled or performed manually.

When the Sword package is received by DSpace, QuickSubmit will update the status
as appropriate. If there is no workflow enabled, QuickSubmit will receive a
Handle immediately and send it to the submitter. If workflow is enabled,
QuickSubmit will email the user explaining that our staff needs to approve the
submission and they will receive a follow up email after it is approved with the
persistent URL.

```
NOTE: Anything that happens in workflow, such as embargo setting, is not
dependent on any QuickSubmit logic and should be treated as DSpace itself.
Two exceptions (crosswalk and install event) follow that were added specifically
to support QuickSubmit's needs. However, even these should be thought of as
DSpace and not QuickSubmit.
```

### Crosswalk

Logic was added to our DSpace crosswalk that sets the funders to appropriate fields metadata fields.

### Install Event

A feature was added to DSpace to post some JSON to the `callback_uri` as part
of the `dspace install event`.

The `callback_uri` is included in the METS, and DSpace should post back JSON to
include the status of `approved` along with a handle when the submission is
approved into the repository. If Submissions are automatically approved and
the handle is returned during the Sword deposit, this is unnecessary to
configure at the repository level.

The `callback_uri` contains a UUID for the Submission in QuickSubmit as part
of the URI so there is no need to include that in the JSON.

Example JSON:
```json
{
  "status": "approved",
  "handle": "http://handle.net/123456/789"
}
```

### DSpace Cleanup tasks

The `callback_uri` should be removed from the DSpace record metadata after the
record live. This does not have to be removed immediately, but there is no value
in retaining the `callback_uri` as part of our permanent record as it was only
necessary to allow QuickSubmit and DSpace to communicate.

## Developing this Application

### Testing with FakeS3

To prevent using a real S3 service in testing (and development if
you prefer), you can use the provided rake tasks `rake fakes3:start`
and `rake fakes3:stop` to spin up a fake of the service.

### Minimum Environment Variables for development

You can copy these into a .env file and use `heroku local` (included with the
   [Heroku Toolbelt](https://toolbelt.heroku.com)) to launch the application.
   You may want to remove the second line of Profile to disable processing of
   the job queue depending on what portions of the application you are working
   on.

`FAKE_AUTH_ENABLED=true` see Optional Environment Variables

`S3_BUCKET=fakebucket` see Environment Variables

`AWS_ACCESS_KEY_ID=12345` see Environment Variables

`AWS_SECRET_ACCESS_KEY=12345` see Environment Variables

NOTE: You'll need to add the 3 SWORD_* variables if you want to deliver packages in development

### Environment Variables

`EMAIL_FROM`: this is the default email address messages will be sent from

`MIT_OAUTH2_API_KEY`: key provided by MIT's OAuth service

`MIT_OAUTH2_API_SECRET`: secret provided by MIT's OAuth service

`SWORD_ENDPOINT`: URI of the sword service to deposit packages to

`SWORD_USERNAME`: username for sword endpoint

`SWORD_PASSWORD`: password for the sword endpoint

`S3_BUCKET`: whatever your bucket is. With fakes3 (for dev/test) using `fakebucket` as a value is best.

`AWS_ACCESS_KEY_ID`: your Amazon S3 bucket access key id. (not required with fakes3)

`AWS_SECRET_ACCESS_KEY` your Amazon S3 bucket secret access key. (not required with fakes3)

### Optional Environment Variables

`DISABLE_ALL_EMAIL`: set to `true` to not send any emails at all. This
disables critical communication portions of the app and should not be used
in production. This option is likely to be removed in the future.

`FAKE_AUTH_ENABLED`: set to `true` to use `:devloper` mode Omniauth which
prompts for and accepts any name/email combination. This is useful in PR
testing to avoid needing to configure the OpenID provider with a fleeting
hostname of the PR site. It can also be use in development, but never in
production.

repository: MITLibraries/QuickSubmit

gha_language: Ruby

repo_name: MITLibraries/QuickSubmit


text:
---
layout:     post
title:      Introduction to jlink
date:       2017-11-07 12:31:19
summary:    /me dips toe into jlink
tags:
- java
---

Naturally, Question 1 is: What is `jlink`?

TL;DR: It's a tool for creating small custom JVMs containing *only* the bits you need. They take less disk space and start faster than the full JVM.

Full Answer:

> You can use the jlink tool to assemble and optimize a set of modules and their dependencies into a custom runtime image.

Indeed the simplest way to use [`jlink`](https://docs.oracle.com/javase/9/tools/jlink.htm) is to use Java modules yourself. There is a lot written about modules elsewhere so I won't add to the pile, just assume you know roughly what they are. One critical point: **modules have to state which other modules they depend on**. The JDK itself is now modularized with the dependencies explicit ([visualised here](https://github.com/accso/java9-jigsaw-depvis#what-is-this-about)). I shudder to think about how much hard work went into that!

If you package your code as a module then your code and its dependencies (including transitive ones) can be isolated from unused modules and a custom JVM can be created containing *only* necessary modules. That's what `jlink` does.

If you do not package your code as a module then you can use the `jdeps` tool to identify module dependencies and have `jlink` create a JVM with only those modules you specify.

Don't use [`java.xml`](https://docs.oracle.com/javase/9/docs/api/java.xml-summary.html)? Don't need it.  Don't want [swing](https://docs.oracle.com/javase/9/docs/api/javafx.swing-summary.html)? Don't have it then. Simple.

(Edit: This section used to incorrectly claim that modularising your code was the *only* way to use `jlink`. Thanks [Claes](https://twitter.com/cl4es) for pointing out my error)

For the rest of this post I'll show you how to create a minimal Java module and use `jlink` to create a minimal JVM image. I'll chuck in some measurements too, free of charge.

## A minimal Java module

Create a source directory

```shell
$ mkdir -p src/mjg123.module/mjg123/module
$ cat > src/mjg123.module/module-info.java
module mjg123.module {}

$ cat > src/mjg123.module/mjg123/module/Main.java
package mjg123.module;

public class Main {
  public static void main(String... args){
    System.out.println("Hello from mjg123.module");
  }
}

$ tree src
src
└── mjg123.module
    ├── mjg123
    │   └── module
    │       └── Main.java
    └── module-info.java
```

Our module has no dependencies, except the implicit dependency on `java.base`.

Compile it:

```shell
$ javac -d mods/mjg123.module \
        src/mjg123.module/module-info.java \
        src/mjg123.module/mjg123/module/Main.java
```

We have made a module! Yeah!

```shell
$ tree mods
mods
└── mjg123.module
    ├── mjg123
    │   └── module
    │       └── Main.class
    └── module-info.class
```

## Running our module

We can run it using the `--module-path` and `-m` options:

```shell
$ java --module-path mods -m mjg123.module/mjg123.module.Main
Hello from mjg123.module
```

We have ourselves a module, and I do believe we're ready to use `jlink`!

## Using jlink

```shell
$ jlink --module-path $JAVA_HOME/jmods:mods --add-modules mjg123.module --output linked
```

It takes a couple of seconds to create the new binaries in `linked/bin`, and we run the code just as before but using the new `java` binary. We don't need to specify `--module-path` because it's already linked in, and removing it will elide some runtime cost of scanning the module path.

```shell
$ linked/bin/java -m mjg123.module/mjg123.module.Main
Hello from mjg123.module
```

## Measurements

### Module count

```shell
$ java --list-modules | wc -l
99
```

```shell
$ linked/bin/java --list-modules
<EMAIL_ADDRESS>mjg123.module
```

### Disk usage

My `$JAVA_HOME` is 557Mb. How about the new one?

```shell
$ du -sh linked
45M     linked
```

There is some more stuff we could trim away in there, but this is already a lot smaller. If you're distributing your code with the JVM bundled with it (eg in a container image) then the benefit is clear.

### Execution time

If you read my previous posts you'll know that I am [mildly](/2017/10/02/JVM-startup.html) [obsessed](/2017/10/04/AppCDS-and-Clojure.html) with [startup time](/2017/10/16/Clojure-1.9-startup.html). Here's a couple of quick measurements:

Full JDK distribution:

```shell
$ perf stat -r50 java --module-path mods -m mjg123.module/mjg123.module.Main
...snip...
       0.204575188 seconds time elapsed                                          ( +-  1.39% )
```

As shrunk by `jlink`:

```shell
$ perf stat -r50 linked/bin/java -m mjg123.module/mjg123.module.Main
...snip...
       0.122966645 seconds time elapsed                                          ( +-  1.09% )
```

40% improvement with no extra effort. We can also use CDS trivially:

```shell
$ linked/bin/java -Xshare:dump
...ignore warnings about missing classes...

$ perf stat -r50 linked/bin/java -Xshare:on -m mjg123.module/mjg123.module.Main
...snip...
       0.098581867 seconds time elapsed                                          ( +-  1.65% )
```

BAM! Another 24ms gone - we're twice as fast as before!

## Conclusion

![graph]({{ "assets/jlink_startup.png" | absolute_url }})

If you're able to specify which Java modules you need, `jlink` is an easy way to improve the size and speed of your Java apps. I would expect AOT and AppCDS to make it even faster. If startup time is a critical factor in your application then it makes modules a very appealing feature of the JDK.

The ever-excellent Trisha Gee has some advice about [migrating existing code into modules](https://www.infoq.com/articles/Java-Jigsaw-Migration-Guide).

Thanks for help writing this post: Alex Bransby-Sharples, Claes Redestad, Alan Bateman.

gha_language: HTML


text:
# Development Strategy

> `project-local-storage-event-delegation`

A beginner project where we work collaboratively on Document Object Model. That is a small site with sort of tapas menu, where site-visitor can add things which save in menu after refresh the page. Also if site-visitor want he can check and uncheck menu items. And he hes special button for toggle all items by pressing and clear all items with the Clear All button.
For the aim to alive the page it's added css-effects: spacing/blur/base color.

## Wireframe

![wireframe](./wireframe.png)

## 0. Set-Up

### Repository

- Created a new repository
- Cloned the repository
- Added HTML and CSS features for user interface
- Added JS template files
- Started `development-strategy.md` file
- Created issues
- Pushed the changes
- Turned on GitHub Pages

## 1. Button Add-item

**As a site visitor...**

> assigned to `oguz`
> reviewers `olga` , `yauh` and `sayed`

## Repo

This user story was developed on a branch called `add-item`

## JS

- Got element with `querySelector` method
- Created an array to store user input
- Created a function to get user input and store in our array with `push()` method
- Used `LocalStorage`, `.setItem()` and `.getItem()` property to prevent the list disappear when the page is refreshed
- Created another function for converting our array to a string with `map()` method and change the HTML content with `.innerHTML` property

## HTML

- I moved the `script` tags into the `body` tag

---

## 2. Function to save items

**As a site visitor I want to see my list saved**

> assigned to `Yauheniya`
> reviewers `Oguz` , `Olga` and `Pavel`

## Repo

This user story was developed on a branch called `save`

## JS

- Oguz created function for converting our array to a string with `map()` method and change the HTML content with `.innerHTML` property, with `join` method to finalise.

## HTML

- Added input tag for visual checkbox option with JS ternary condition.

---

## 3. Function to check/ uncheck items

**As a site visitor I want to be able to check or uncheck items from menu...**

> assigned to `Sayed`
> reviewers `Oguz` and `Olga`

## Repo

This user story was developed on a branch called `Done-item`

## JS

- created the function called `checkedDone()`
- Added an `input` element in `add-item.js`
- Added event listener

## HTML

- Nothing

## CSS

---

## 4. Update CSS variables: spacing-blur-base-color

**As a site visitor I want to change background of tapas-menu with color-picker and change the blur and spacing of logo-fish with special progress bar**

> assigned to `Olga`
> reviewers `Oguz` and `Pavel`

## Repo

This user story was developed on a branch called `spacing-blur-color`

## JS

- Use `window.onload` property
- Got element with `getElementByID` and `querySelector` method
- Got `forEach` method to call `function addEventListenerToElem` to each input-element in `div #controls`
- Create `function addEventListenerToElem()` to assign event-listener `mousemove` for progress-bar (effect spacing and blur) and `change` for color-picker
- Create `function handleUpdate()` for realize css-effects

## HTML

- moved the script-tag for `spacing-blur-base-color.js` inside head-tag
- add `div id-"controls"` for adding two progress-bars (spacing and blur) and color-picker

## CSS

- Add stile for CSS-controls `input` like as tapas-menu
- Assign `var` for color-picker, spacing and blur in `root-selector`
- Change value for properties padding and filter of `svg-selector` and for background of `.wrapper-selector` on variables from `root`

---

## 5. `Clear All` and `Toggle all items` buttons

**As a site visitor I can toggle all items by pressing and appropriate button. Also I can clear all items with the Clear All button**

> assigned to `Pavel`
> reviewers `Olga` , `Oguz`
> closes issue #6

## Repo

This user story was developed on a branch called `additional-buttons`

## JS
The `onload` event listener was added, which callback function creates two buttons on the page and assigns `onclick` event to every button.

## HTML
Script tag with the `items-handler-btns.js` was added. This script contains the callback and service functions for the `onload` event

## CSS

Some CSS was added to style the handler buttons.

---

gha_language: JavaScript


text:
---
author: kubu4
comments: true
date: 2018-04-19 21:28:52+00:00
layout: post
slug: kmer-estimation-kmergenie-on-geoduck-sequence-data-default-settings
title: Kmer Estimation - Kmergenie on Geoduck Sequence Data (default settings)
wordpress_id: 3270
author:
  - kubu4
categories:
  - Geoduck Genome Sequencing
tags:
  - geoduck
  - kmer
  - kmer genie
  - mox
  - Panopea generosa
---

After the [last SparseAssembler assembly completed](https://robertslab.github.io/sams-notebook/2018/04/05/genome-assembly-sparseassembler-geoduck-genomic-data-kmer101.html), I wanted to do another run with a different kmer size (last time was arbitrarily set at 101). However, I didn't really know how to decide, particularly since this assembly consisted of mixed read lenghts (50bp and 100bp). So, I ran [kmergenie](https://kmergenie.bx.psu.edu/README) on all of our geoduck (_Panopea generosa_) sequencing data in hopes of getting a kmer determination to apply to my next assembly.

The job was run on our Mox HPC node.

Slurm script: [20180419_kmergenie_geoduck_slurm.sh](https://owl.fish.washington.edu/Athaliana/20180419_kmergenie_geoduck/20180419_kmergenie_geoduck_slurm.sh)

Input files list (needed for kmergenie command - see Slurm script linked above): [geoduck_fastq_list.txt](https://owl.fish.washington.edu/Athaliana/20180419_kmergenie_geoduck/geoduck_fastq_list.txt)

##### Results:

Output folder: [20180419_kmergenie_geoduck/](https://owl.fish.washington.edu/Athaliana/20180419_kmergenie_geoduck/)

Slurm output file: [20180419_kmergenie_geoduck/slurm-161551.out](https://owl.fish.washington.edu/Athaliana/20180419_kmergenie_geoduck/slurm-161551.out)

Kmer histograms (HTML): [20180419_kmergenie_geoduck/histograms_report.html](https://owl.fish.washington.edu/Athaliana/20180419_kmergenie_geoduck/histograms_report.html)

Screen cap from Kmer report:

![](https://owl.fish.washington.edu/Athaliana/20180419_kmergenie_geoduck/20180419_kmer_plot.png)

This data estimates the best kmer size for this data to be 121.

However, based on the [kmergenie documentation](https://owl.fish.washington.edu/Athaliana/20180419_kmergenie_geoduck/histograms_report.html#advhelp), this is likely to be inaccurate. This inaccuracy is based on the fact that our kmer graph should be concave. Our graph, instead, is only partial - we haven't reached a kmer size where the number of kmers is decreasing.

As such, I'll try re-running with a different maximum kmer settting (default max is 121).

repository: RobertsLab/sams-notebook

extension: markdown

gha_language: Shell

repo_name: RobertsLab/sams-notebook


text:
---
title: "Hyperparameter tuning"
sub_link: "sweep/introduction"
is_index: true
meta_title: "Hyperparameter tuning and sweeps - Experimentation"
meta_description: "Polytune is a library to dynamically find the best set of hyperparameter values that will minimize or maximize a particular metric."
visibility: public
status: published
tags:
    - sweep
    - experimentation
    - hyperparameter-optimization
sidebar: "experimentation"
---

## Overview

[Polytune](https://github.com/polyaxon/polyaxon/tree/master/core/polyaxon/polytune)
is a library to dynamically find the best set of hyperparameter values that will minimize or maximize a particular metric.
It's based on open-source work and algorithms that you can customize and control.
Polytune can make suggestions for hyperparameter values to try sequentially or in parallel (or both).

## Features

 * Easy-to-use: Polytune is an open-source Python library, it's lightweight, and can be used with the rest of your packages.
 * Flexibility: It's customizable and provides several built-in distributions and algorithms.
 * Total control: You can start experiments programmatically, you can use your own scheduler, and you control how many experiments to start and when to end them.

> Documentation in progress.

repository: erexer/polyaxon

repo_name: erexer/polyaxon


text:
---
layout: post
title:  "Interesting article"
date:   2018-08-20 17:00:00
categories: DPDK
tags: DPDK virtio
excerpt: Zero-copy Optimization for DPDK vhost-user Receiving
mathjax: true
---

DPDK provides vhost-user dequeue zero copy, and this feature is only used for traffic from vhost-user.

[Zero-copy Optimization for DPDK vhost-user Receiving](https://yq.aliyun.com/articles/604505)

[Zero-Copy Optimization for Alibaba Cloud Smart NIC Solution](https://www.alibabacloud.com/blog/zero-copy-optimization-for-alibaba-cloud-smart-nic-solution_593986)

This article proposes a solution to support zero copy at DPDK vhost-user receiving side.


text:
# README

# Live-In Fear

This is the backend component of Live-In Fear, the applciation that uses government death-and-injury statistics to provide a risk-rating for everything in your house. You can create rooms and add items, and then understand how likely it is that that room will kill you!

Things you may want to cover:

* Ruby version: 3.0

* System dependencies

* Configuration

* Database creation

* Database initialization

* How to run the test suite

* Services (job queues, cache servers, search engines, etc.)

* Deployment instructions

* ...


text:
# Solid Mechanics Application

This application focuses on the Finite Element Method (FEM) for solids, shells and beams.

The SolidMechanics application team are in charge of all developments related to this application.

## Getting Started

This application is part of the Kratos Multiphysics Platform.
Instructions on how to update, build and run it on your local machine are available.
Please contact:

* **Josep Maria Carbonell** - *Core Development* - [cpuigbo<EMAIL_ADDRESS>
## Theory

Classical FE method theory for small and large displacements.

[original wiki web page](http://kratos-wiki.cimne.upc.edu/index.php/Solid_Mechanics_Application)

## Solid Elements

![Open cylinder pullout animation](tests/tests_data/dynamic_3d_beam.gif)

### Displacement based formulations:

Infinitessimal formulation, Total Lagrangian formulation, Updated Lagrangian formulation.

Bbar element for second order elements and infinitessimal theory.

### Mixed elements:

U-P formulation for linear triangles and linear tetrahedra. Monolitich approach with Bochev stabilization.

## Structural Elements:

### Shells

Co-rotational thick and thin 3D shells theory. Large displacements and large rotations.

![Open cylinder pullout animation](tests/tests_data/shell_roll_up.gif)

### Beams

Geometrically exact theory for 3D beams. Large displacements and large rotations.

![Open cylinder pullout animation](tests/tests_data/beam_roll_down.gif)

### Material Laws

The Material laws are implemented in [this application](https://github.com/KratosMultiphysics/Kratos/tree/master/applications/ConstitutiveModelsApplication).

### Time integration schemes

The standard schemes for displacement and rotation degrees of freedom. The following schemes can be chosen separately for -displacements- and for -displacements and rotations-:

* Newmak Scheme
* Bossak Scheme
* Simo scheme
* Static scheme ( no time integration is performed )

### Contact mechanics

The mechanics of contact is implemented in [this application](https://github.com/KratosMultiphysics/Kratos/tree/master/applications/ContactMechanicsApplication).

## Available Interfaces

### GiD Interface

It is located in GiD interface repository in [GiD interface repository](https://github.com/KratosMultiphysics/GiDInterface/tree/master/).

Requires [GiD](https://www.gidhome.com/) - Pre and Post Processing software.

## Releases

The last release of the Solid Mechanics application is supplied with GiD the interface, it can be automatically downloaded in Data->Problem_type->Kratos :: Solid (in application market)

## License

The Solid Mechanics application is OPEN SOURCE. The main code and program structure is available and aimed to grow with the need of any user willing to expand it. The BSD (Berkeley Software Distribution) licence allows to use and distribute the existing code without any restriction, but with the possibility to develop new parts of the code on an open or close source depending on the developers.

## Contact

* **Josep Maria Carbonell** - *Core Development* - [cpuigbo<EMAIL_ADDRESS>

repository: KratosMultiphysics/Kratos

repo_name: KratosMultiphysics/Kratos


text:
---
layout:     post
title:      Filter list of include static entries
date:       2014-12-15
summary:    CMS 7 - Simple way to filter the include statics in the template record
categories: typo3 cms7 filter ts
og-image:   typo3-include-static-filter.gif
---

A nice improvement just got merged into the master of TYPO3 CMS! Just one line has been added but
it makes the live of an integrator a bit easier.<!--more-->

See the animated gif below for a short impression:

![Screen capture of filtering](/assets/typo3-include-static-filter.gif)

This is not a new feature but already possible since quite a while. If you need something like that as well,
just use the following **TCA configuration**:

	'enableMultiSelectFilterTextfield' => TRUE,

If you want to get to know more kind of hidden features of the TCA, please take a look at the styleguide which covers
nearly all possible options: [github.com/7elix/TYPO3.CMS.Styleguide](https://github.com/7elix/TYPO3.CMS.Styleguide)


text:
---
layout: post
comments: true
title: Capture container logs in Kubernetes with Splunk Connect
excerpt: Learn how to capture and forawrd logs from Pods running in Kubernetes to Splunk.
categories: monitoring
tags: [kubernetes,splunk,logs]
toc: true
img_excerpt:
---

Splunk allows the collection and analyzes of high volumes of machine-generated data (e.g. application logs). Once the data becomes indexes in Splunk, one can build reporting dashboard and alerts based of specific search. For instance, one can build a dashboard for application crashes, or failures to handle incoming request and track this over time.
Splunk provides many integrations that makes it very easy to collect logs from a varied of sources. In this article, we will examine how to collect logs from cloud native applications running on Kubernetes.

## Setting up Splunk

> Note: if you already have a Splunk instance or an account on Splunk Cloud then you can skip this step.

### Splunk Operator
We can easily setup Splunk on Kubernetes using the official operator - [link](https://github.com/splunk/splunk-operator/).

First, create a Kubernetes namespace to host the pods of the Splunk operator as well as Splunk itself.

```
$ kubectl create namespace monit
```

Second, install Splunk official operator in the newly created namespace as follows

```
$ kubectl apply -f https://github.com/splunk/splunk-operator/releases/download/1.0.2/splunk-operator-install.yaml -n monit
customresourcedefinition.apiextensions.k8s.io/clustermasters.enterprise.splunk.com created
customresourcedefinition.apiextensions.k8s.io/indexerclusters.enterprise.splunk.com created
customresourcedefinition.apiextensions.k8s.io/licensemasters.enterprise.splunk.com created
customresourcedefinition.apiextensions.k8s.io/searchheadclusters.enterprise.splunk.com created
customresourcedefinition.apiextensions.k8s.io/standalones.enterprise.splunk.com created
serviceaccount/splunk-operator created
role.rbac.authorization.k8s.io/splunk:operator:namespace-manager created
rolebinding.rbac.authorization.k8s.io/splunk:operator:namespace-manager created
deployment.apps/splunk-operator created
```

After few seconds, the operator will become ready to use, you can check the Pod status with

```
$ kubectl get pods -n monit
NAME                              READY   STATUS    RESTARTS   AGE
splunk-operator-f7c8d94f9-tsp9z   1/1     Running   0          10s
```

### Splunk Standalone
Now, we can deploy Splunk using this operator

```
$ cat <<EOF | kubectl apply -n monit -f -
apiVersion: enterprise.splunk.com/v2
kind: Standalone
metadata:
  name: s1
  finalizers:
  - enterprise.splunk.com/delete-pvc
EOF
standalone.enterprise.splunk.com/s1 created
```

> Note: In this case we are installing a standlone deployment as we will use Splunk for testing, in reality a more advance configuration is needed to insure High Availability.

After few moments, Splunk Pods will become available and ready to be used. We can check their status as follows:

```
$ kubectl get pods -n monit
NAME                                  READY   STATUS    RESTARTS   AGE
splunk-default-monitoring-console-0   1/1     Running   0          3m19s
splunk-operator-f7c8d94f9-tsp9z       1/1     Running   0          6m38s
splunk-s1-standalone-0                1/1     Running   0          5m56s
```

### Splunk credentials
To get the credentials to access Splunk Web UI with `kubectl` we can print the secret created as part of the deployment of Splunk as follows:

```
$ kubectl get secret splunk-monit-secret -o yaml -n monit
apiVersion: v1
data:
  hec_token: N0NEMDQwRDgtMDc0NC1EOEQ3LTU1NDgtOTg4NzY1QTZDODA2
  idxc_secret: U3BHWUhsS1lIajdXRFpsOFkxcVh1UDQy
  pass4SymmKey: TUtnZjVOTXZhUEs4WnFTQzc0V0V2S2hu
  password: QVJEcEZ6OWx1OHJEbnl2MjJlU0FwTDhh
  shc_secret: T1Yxd3p4bGlNZTJkcEZkNzhsOVRXbm9T
kind: Secret
metadata:
  creationTimestamp: "2021-08-25T17:32:03Z"
  managedFields:
  - apiVersion: v1
    fieldsType: FieldsV1
    fieldsV1:
      f:data:
        .: {}
        f:hec_token: {}
        f:idxc_secret: {}
        f:pass4SymmKey: {}
        f:password: {}
        f:shc_secret: {}
      f:metadata:
        f:ownerReferences:
          .: {}
          k:{"uid":"3ba7943f-b283-452d-9917-02ebb7f7d114"}:
            .: {}
            f:apiVersion: {}
            f:controller: {}
            f:kind: {}
            f:name: {}
            f:uid: {}
      f:type: {}
    manager: splunk-operator
    operation: Update
    time: "2021-08-25T17:32:03Z"
  name: splunk-default-secret
  namespace: default
  ownerReferences:
  - apiVersion: enterprise.splunk.com/v2
    controller: false
    kind: Standalone
    name: s1
    uid: 3ba7943f-b283-452d-9917-02ebb7f7d114
  resourceVersion: "851"
  uid: 15ed8cc4-6af0-438d-8568-0b096454c2f1
type: Opaque
```

> Note: the secret name splunk-monit-secret is a composed name of the <splunk-deployment>-<namespace>-secret. If splunk is deployed in the default namespace, the secret name will be splunk-default-secret

To get the values of all the secrets stored here we can do

```
$ kubectl get secret splunk-monit-secret -n monit -o go-template=' {{range $k,$v := .data}}{{printf "%s: " $k}}{{if not $v}}{{$v}}{{else}}{{$v | base64decode}}{{end}}{{"\n"}}{{end}}'
hec_token: 7CD040D8-0744-D8D7-5548-988765A6C806
idxc_secret: SpGYHlKYHj7WDZl8Y1qXuP42
pass4SymmKey: MKgf5NMvaPK8ZqSC74WEvKhn
password: ARDpFz9lu8rDnyv22eSApL8a
shc_secret: OV1wzxliMe2dpFd78l9TWnoS
```

To get one specific secret, for instance the Splunk Web UI password of the `admin` user we can do

```
$ kubectl get secret splunk-monit-secret -n monit -o go-template='{{ index .data "password" }}' | base64 -d
ARDpFz9lu8rDnyv22eSApL8a
```

Then we can access the Web UI by setting up port-forwarding to Splunk as follows

```
$ kubectl port-forward splunk-s1-standalone-0 8000 -n monit
Forwarding from <IP_ADDRESS>:8000 -> 8000
Forwarding from [::1]:8000 -> 8000
```

## Splunk Connect
To be able to send logs to our Splunk deployment we need to get credentials. In our case, we specifically need [HEC (HTTP Event Collector) token](https://docs.splunk.com/Documentation/Splunk/8.2.4/Data/UsetheHTTPEventCollector).

We can get this HEC token using `kubectl` or using Splunk admin page as follows:

![splunk-hec]({{ "assets/2022/01/20220104-splunk-hec.gif" | absolute_url }}){: .center-image }

To get the HEC token using `kubectl` instead we can do

```
$ kubectl get secret splunk-monit-secret -n monit -o go-template='{{ index .data "hec_token" }}' | base64 -d
ARDpFz9lu8rDnyv22eSApL8a
```

### Configuration file
We need to pupulate a custom version of [values.yaml](https://github.com/splunk/splunk-connect-for-kubernetes/blob/develop/helm-chart/splunk-connect-for-kubernetes/values.yaml) with information specific to our Splunk instance like hostname and HEC token.

We need to create some environment variables to use when filling in the `values.yaml` file.

**1.** get Get splunk server address, use DNS name `<service>.<namespace>` or just `<service>`

```
$ hostname="splunk-s1-standalone-service"
```

**2.** get the Splunk HEC token into a variable

```
$ token=`kubectl get secret splunk-monit-secret -n monit -o go-template='{{ index .data "hec_token" }}' | base64 -d`
```

**3.** get the Splunk admin password into a variable

```
$ password=`kubectl get secret splunk-monit-secret -n monit -o go-template='{{ index .data "password" }}' | base64 -d`
```

**4.** choose the index name to be used by Splunk to host the logs

```
$ index="main"
```

**5.** pick a filename where the values will created.

```
$ file=$(mktemp /tmp/splunk-connect-values.XXXXXX)
```

**6.** Create the values file and configure each section.

For instance, the bare minimum file would look like this where we disable sending to Splunk the kubernetes objects and metrics but only allow logging messages to be sent.

```
$ cat >"${file}" << EOF
global:
  splunk:
    hec:
      host: ${hostname}
      port: 8088
      token: ${token}
      protocol: https
      indexName: ${index}
      insecureSSL: true

splunk-kubernetes-logging:
  enabled: true
splunk-kubernetes-objects:
  enabled: false
splunk-kubernetes-metrics:
  enabled: false
EOF
```

> Note: by default the expected log format is JSON

But your containers may output text logs that can be on multi-line like the example below

```
2022-01-05T16:52:17.283-0800 level=INFO thread=thrad1 logger=dzlab.logger
This is the log message
```

In such case, you can customize the logs section in the values file as follows:

```
$ cat >"${file}" << EOF
global:
  splunk:
    hec:
      host: ${hostname}
      port: 8088
      token: ${token}
      protocol: https
      indexName: ${index}
      insecureSSL: true

splunk-kubernetes-logging:
  enabled: true
  containers:
    logFormat: '%Y-%m-%dT%H:%M:%S.%N%:z'
    logFormatType: cri
  logs:
    applogs:
      from:
        pod: '*'
      multiline:
        firstline: /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}[-+]\d{4}/
        separator: ""

splunk-kubernetes-objects:
  enabled: false
splunk-kubernetes-metrics:
  enabled: false
EOF
```

> Note: the url to Splunk endpoint is given through the fields `host`, `port` and `protocol`. But you can also provide a full url (e.g. if the endpoint is behind a proxy) using `full_url` field. For details, see the following [Pull Request](https://github.com/splunk/splunk-connect-for-kubernetes/pull/683/files).

### Installation with Helm

To be able ot install Splunk Connect with Helm, we to indicate to Helm where to find the charts. For this, add the Splunk Connect github repository to the list of local Help repositories
```
$ helm repo add splunk https://splunk.github.io/splunk-connect-for-kubernetes/
"splunk" has been added to your repositories
```

Now we can install Splunk Connect on the monitoring namespace using the custom values file we created in the previous section.

```
$ helm install splunkconnect -n monit -f "${file}" splunk/splunk-connect-for-kubernetes
NAME: splunkconnect
LAST DEPLOYED: Wed Aug 25 11:26:37 2021
NAMESPACE: default
STATUS: deployed
REVISION: 1
TEST SUITE: None
NOTES:
███████╗██████╗ ██╗     ██╗   ██╗███╗   ██╗██╗  ██╗██╗
██╔════╝██╔══██╗██║     ██║   ██║████╗  ██║██║ ██╔╝╚██╗
███████╗██████╔╝██║     ██║   ██║██╔██╗ ██║█████╔╝  ╚██╗
╚════██║██╔═══╝ ██║     ██║   ██║██║╚██╗██║██╔═██╗  ██╔╝
███████║██║     ███████╗╚██████╔╝██║ ╚████║██║  ██╗██╔╝
╚══════╝╚═╝     ╚══════╝ ╚═════╝ ╚═╝  ╚═══╝╚═╝  ╚═╝╚═╝

Listen to your data.

Splunk Connect for Kubernetes is spinning up in your cluster.
After a few minutes, you should see data being indexed in your Splunk.

If you get stuck, we're here to help.
Look for answers here: http://docs.splunk.com

Warning: Disabling TLS will send the data unencrypted and will be vulnerable to MiTM attacks
```

After successfully deploying Splunk Connect an index called `main` will be created, we can check this in the Splunk UI (at `http://localhost:8000` with login `admin`:`${password}`)

We can also check logs from our Pods are forwarded properly to splunk


text:
### [CVE-2012-0782](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2012-0782)
![](https://img.shields.io/static/v1?label=Product&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=n%2Fa&color=brighgreen)

### Description

** DISPUTED ** Multiple cross-site scripting (XSS) vulnerabilities in wp-admin/setup-config.php in the installation component in WordPress 3.3.1 and earlier allow remote attackers to inject arbitrary web script or HTML via the (1) dbhost, (2) dbname, or (3) uname parameter. NOTE: the vendor disputes the significance of this issue; also, it is unclear whether this specific XSS scenario has security relevance.

### POC

#### Reference
- http://www.exploit-db.com/exploits/18417

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

repository: trickest/cve

repo_name: trickest/cve


text:
# FlashDiscord

Simple proof of concept showing how to build and use an AIR Native Extension, or ANE. The concept is applied to the Discord SDK C library, which means that we could theoretically use it to add a discord voice chat in any Flash app running on AIR.

This example is more like guidelines and should not be used "as is": it was developped with a specific OS/C++/AIR environment, and it's unlikely you'll end up with the exact same one. If you've already played with AIR and C++ you should be able to understand what's goind on though.

## Prerequisites

- Working AIR dev environment (``AS3, MXML, and SWF Extension Pack`` on VS Code)
- C++ compiler (MSVC++ 14.2)
- [Cmake](https://cmake.org/)
- Discord SDK

It is forbidden to redistribute the sources of the discord SDK, so you first need to download and copy the latest version of the SDK from https://dl-game-sdk.discordapp.net/2.5.6/discord_game_sdk.zip and extract it in NativeDiscordWrapper.

NativeDiscordWrapper should have the following contents:
- discord_game_sdk/
- include/
- src/
- CMakeLists.txt

## NativeDiscordWrapper

Two C++ projects that can be built using CMake:

- a C++ dll that is our wrapper around Discord stuff. If ANE_BUILD is set in CMake, it is built with the AIR stuff to be called from AIR apps. Otherwise it is a standard C++ library.
- a C++ exe, just a main with a few lines. Used to test that the wrapped functions work the way we want.

## AIRDiscordLibrary

ActionScript wrapper around the C++ dll. It has a copy of all functions we want to call in the dll, and can react to events sent by the dll. Compiled to a .xml and .swc file.

## ANE Packing

The ``pack.bat`` file will gather all the files and call the commands needed to create the ANE file. This step can also be performed by hand. If you're not on Windows, you might have to use different commands, but it should be quite easy as it only uses basic stuff. Once the .ane file is generated, it has to be copied to ``AIRDiscordExe/extensions/``.

Warning: the debug version of the dll is copied, if you want to use the Release one or if you're not on Windows, you'll need to change the path.

## AIRDiscordExe

Main AIR app using the AIRDiscordLibrary developped earlier. Before building, you might want to change the .pfx file with the password AIR thing in ``asconfig.json``.

The project is built as a standalone AIR app, with a very inspired name: Main.exe. In order to work, you must copy ``NativeDiscordWrapper/discord_game_sdk/lib/x86/discord_game_sdk.dll`` next to ``Main.exe``. If discord is launched on the same computer, it should display the current user name.

AS3 doesn't have 64 bits int, while discord uses them everywhere, so they are passed as strings instead.

## License

MIT

repository: adepierre/FlashDiscord

repo_name: adepierre/FlashDiscord


text:
---
layout: post
title: Christmas Wreath Coloring Page - Part 2
subtitle: Free and Printable Christmas Wreath Coloring Page - Part 2
categoties: [Coloring Pages]
---
{{ page.title }}
================
> This page is about [Christmas Wreath Coloring Page](https://freecoloringpages.github.io/). Wreaths are made from real or artificial conifer branches, or sometimes other broadleaf evergreens or holly. Several types of evergreen or even deciduous branches may be used in the same wreath, along with pinecones and sprays of berries, and Christmas ornaments including jingle bells. A bow is usually used at the top or bottom, and an electric or unlit candle may be placed in the middle. Christmas lights are often used, and they may be hung from door or windows, and sometimes walls, lampposts and light fixtures, or even statuary. Since the 19th century, the poinsettia, a native plant from Mexico, has been associated with Christmas. Source: https://wikipedia.org/

**In the series of Christmas Wreath Coloring Page:**

* [Christmas Wreath Coloring Page - Part 1](https://freecoloringpages.github.io/2017/11/21/Christmas-Wreath-Coloring-Page-part-1.html)
* [Christmas Wreath Coloring Page - Part 2](https://freecoloringpages.github.io/2017/11/21/Christmas-Wreath-Coloring-Page-part-2.html)
* [Christmas Wreath Coloring Page - Part 3](https://freecoloringpages.github.io/2017/11/21/Christmas-Wreath-Coloring-Page-part-3.html)
* [Christmas Wreath Coloring Page - Part 4](https://freecoloringpages.github.io/2017/11/21/Christmas-Wreath-Coloring-Page-part-4.html)
* [Christmas Wreath Coloring Page - Part 5](https://freecoloringpages.github.io/2017/11/21/Christmas-Wreath-Coloring-Page-part-5.html)
* [Christmas Wreath Coloring Page - Part 6](https://freecoloringpages.github.io/2017/11/21/Christmas-Wreath-Coloring-Page-part-6.html)
* [Christmas Wreath Coloring Page - Part 7](https://freecoloringpages.github.io/2017/11/21/Christmas-Wreath-Coloring-Page-part-7.html)
* [Christmas Wreath Coloring Page - Part 8](https://freecoloringpages.github.io/2017/11/21/Christmas-Wreath-Coloring-Page-part-8.html)

## Christmas Wreath Coloring Page No. 11
![Christmas Wreath Coloring Page 11](https://freecoloringpages.github.io/img/Christmas-Wreath-Coloring-Page%20(11).jpg "Christmas Wreath Coloring Page 11")

## Christmas Wreath Coloring Page No. 12
![Christmas Wreath Coloring Page 12](https://freecoloringpages.github.io/img/Christmas-Wreath-Coloring-Page%20(12).jpg "Christmas Wreath Coloring Page 12")

## Christmas Wreath Coloring Page No. 13
![Christmas Wreath Coloring Page 13](https://freecoloringpages.github.io/img/Christmas-Wreath-Coloring-Page%20(13).jpg "Christmas Wreath Coloring Page 13")

## Christmas Wreath Coloring Page No. 14
![Christmas Wreath Coloring Page 14](https://freecoloringpages.github.io/img/Christmas-Wreath-Coloring-Page%20(14).jpg "Christmas Wreath Coloring Page 14")

## Christmas Wreath Coloring Page No. 15
![Christmas Wreath Coloring Page 15](https://freecoloringpages.github.io/img/Christmas-Wreath-Coloring-Page%20(15).jpg "Christmas Wreath Coloring Page 15")

## Christmas Wreath Coloring Page No. 16
![Christmas Wreath Coloring Page 16](https://freecoloringpages.github.io/img/Christmas-Wreath-Coloring-Page%20(16).jpg "Christmas Wreath Coloring Page 16")

## Christmas Wreath Coloring Page No. 17
![Christmas Wreath Coloring Page 17](https://freecoloringpages.github.io/img/Christmas-Wreath-Coloring-Page%20(17).jpg "Christmas Wreath Coloring Page 17")

## Christmas Wreath Coloring Page No. 18
![Christmas Wreath Coloring Page 18](https://freecoloringpages.github.io/img/Christmas-Wreath-Coloring-Page%20(18).jpg "Christmas Wreath Coloring Page 18")

## Christmas Wreath Coloring Page No. 19
![Christmas Wreath Coloring Page 19](https://freecoloringpages.github.io/img/Christmas-Wreath-Coloring-Page%20(19).jpg "Christmas Wreath Coloring Page 19")

## Christmas Wreath Coloring Page No. 20
![Christmas Wreath Coloring Page 20](https://freecoloringpages.github.io/img/Christmas-Wreath-Coloring-Page%20(20).jpg "Christmas Wreath Coloring Page 20")


text:
## ACL crawling

[ACL anthology](http://www.aclweb.org/anthology/) crawling and analytics.

* Similar; more broad: [AMiner](http://arnetminer.org/introduction)
* Special focus: [Collection of Computer Science Bibliographies](http://liinwww.ira.uka.de/bibliography/)
* Michigan's [ACL Anthology Network](http://clair.eecs.umich.edu/aan/index.php)

## Stats

* There are 20,955 `???-????.bib` files in my current ACL collection.
  - Somehow I only got 20,807 when iterating through. Good enough though.
* There are 33,374 `???-????.pdf` files in the same collection.

## License

Copyright 2013-2014 Christopher Brown. [MIT Licensed](http://opensource.org/licenses/MIT).

repository: chbrown/acl

repo_name: chbrown/acl


text:
[![Build Status](https://travis-ci.org/winzillion/FluxJava.svg?branch=master)](https://travis-ci.org/winzillion/FluxJava) [![Code Coverage](https://img.shields.io/codecov/c/github/winzillion/FluxJava/master.svg)](https://codecov.io/github/winzillion/FluxJava?branch=master) [![Codacy Badge](https://api.codacy.com/project/badge/Grade/9332a0f020784eebbbc8222d534e5480)](https://www.codacy.com/app/winzillion/FluxJava?utm_source=github.com&utm_medium=referral&utm_content=winzillion/FluxJava&utm_campaign=Badge_Grade)
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)

# FluxJava
FluxJava is a java library that implements Flux pattern. And it is small and light-weight can be used easily to follow the Flux pattern.
[Flux](https://facebook.github.io/flux/docs/overview.html) is an architecture designed at Facebook.
With it's one-way data flow principle, it makes tracing changes during development simpler and makes bugs easier to track down and fix.

FluxJava is not only focus on Android projects but also any other Java ones.
Flux is a good practice to help reduce the problems of MVC complicate dependencies when the number of views goes up in Android projects.
It also can be applied into different kinds of interactive interface that need to access data, not just user interface.

# Binaries
You may find the latest version [here](https://github.com/winzillion/FluxJava/releases/latest).

# Setup
For Gradle projects, put the binaries into the folder that build.gradle reference to. In Android case, you can put the files into `libs` folder inside your project or module.

If you want to use `fluxjava-rx` in your project, you may need to add next dependency in the build.gradle of the module:
``` groovy
dependencies {
    ...
    compile "io.reactivex:rxjava:1.3.+”
}
```

If you want to use `fluxjava-rx2` in your project, you may need to add next dependency in the build.gradle of the module:
``` groovy
dependencies {
    ...
    compile 'io.reactivex.rxjava2:rxjava:2.1.+'
}
```

# Getting Started
In this repository, you can find the source of FluxJava in `fluxjava` folder
and a demo Android project in `demo-eventbus` folder.
The demo is a simple todo application with one Activity.
In this demo, you can:
 * View todo list.
 * Switch list between different names.
 * Add a todo.
 * Close/Open a todo.

![demo-screenshot](https://cloud.githubusercontent.com/assets/22995091/20027437/ac19b4fa-a34f-11e6-95f9-d2f0f5159a0c.gif)

This demo project uses [EventBus](https://github.com/greenrobot/EventBus) from [greenrobot](http://greenrobot.org/) to help dispatcher and stores to send out messages.

If you want to get benefit from [RxJava](https://github.com/ReactiveX/RxJava), you can check out `fluxjava-rx` or `fluxjava-rx2` folder for FluxJava addon.
There are two demos duplicated from `demo-eventbus` sitting in `demo-rx` and `demo-rx2` folder.
In these demos, the EventBus is replaced by RxBus from `fluxjava-rx` or `fluxjava-rx2`.
The RxBus provides bus functionalities with RxJava 1.x or 2.x library as EventBus do.

# How to use
## Preparation
* **Bus**

Bus is called by dispatcher and stores to deliver messages.
You need to create your own bus by implement IFluxBus interface.
In this class, you can use your prefer bus solution, like Otto, EventBus, even your own one.
If you also include `fluxjava-rx` in your project, then RxBus will be the one you need.
* **Action**

Dispatcher uses actions to inform store something to do.
There are two properties in Action, type and data.
The type tells store what to do and the data is the additional information for specific action.
In the demo project, when a todo be added from UI, the new todo will be included in the data of action.
* **ActionHelper**

ActionHelper assists ActionCreator to decide which action to create and how to prepare data in action when a request coming.
* **Store**

Store receives the action sent from Dispatcher and processes data base on action.
It will emmit an event when job done then the event listener can refresh the new state of data.
* **Store Map**

StoreMap is a hash map, it tells framework how to get an instance of store.
For example, if the relationship of action and store is one-by-one, you can use Action type for the key of map, or you can simply use Integer to be the key.
In the demo project, you can find two constants in `Constants.java`, DATA_USER and DATA_TODO, they are used to map store. So, TodoStore will be responsible for process todo data request and so on.

## Initialisation
In FluxJava, you can find a FluxContext as entry point of framework.
FluxContext is a singleton, it helps to hook components together and maintain the instance of components.

You can build FluxContext instance by using Builder inside it as below:
``` java
FluxContext.getBuilder()
        .setBus(new Bus())
        .setActionHelper(new ActionHelper())
        .setStoreMap(storeMap)
        .build();
```

## Send Request
After UI component get the input from user, it can push an action through ActionCreator which is got from FluxContext.
The built-in ActionCreator only provides one function - `sendRequest`.
UI component has to input which class of action to be created by an Id and the data get from user.
The data can be transfer into the format for store need later in ActionHelper.

Here is the sample code below:

``` java
Todo todo = new Todo();

FluxContext.getInstance()
        .getActionCreator()
        .sendRequestAsync(TODO_ADD, todo);
```
There are two versions of `sendRequest`, sync and async.
The async version will create new thread and send the message out on it.
If you prefer to control thread by your own or you want to use a thread pool, you can choose the sync version.

## Process Data
Base on which bus solution you used, you need to intercept the specific types of action in store.
You may add a function inside store class with annotation like demo project did.
The code below is the example when using EventBus:
``` java
@Subscribe(threadMode = ThreadMode.BACKGROUND)
public void onAction(final TodoAction inAction) {
    switch (inAction.getType()) {
        case TODO_LOAD:
            ...
            super.emitChange(new ListChangeEvent());
            break;
        case TODO_ADD:
            ...
            super.emitChange(new ListChangeEvent());
            break;
        case TODO_CLOSE:
            ...
            super.emitChange(new ItemChangeEvent(i));
            break;
    }
}
```
If you use `fluxjava-rx`, your store class inherits from RxStore, then you can overwrite `onAction` from RxStore as below:
``` java
@Override
protected <TAction extends IFluxAction> void onAction(final TAction inAction) {
    final TodoAction action = (TodoAction)inAction;

    switch (action.getType()) {
        case TODO_LOAD:
            ...
            super.emitChange(new ListChangeEvent());
            break;
        case TODO_ADD:
            ...
            super.emitChange(new ListChangeEvent());
            break;
        case TODO_CLOSE:
            ...
            super.emitChange(new ItemChangeEvent(i));
            break;
    }
}
```
## Display Change
As store, UI component want to receive the events from store is also base on which bus you use.
In EventBus case:
``` java
@Subscribe(threadMode = ThreadMode.MAIN)
public void onEvent(final TodoStore.ListChangeEvent inEvent) {
    super.notifyDataSetChanged();
}
```
In RxBus case:
``` java
todoStore.toObservable(TodoStore.ListChangeEvent.class)
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(
                new Action1<TodoStore.ListChangeEvent>() {
                    @Override
                    public void call(final TodoStore.ListChangeEvent inEvent) {
                        TodoAdapter.super.notifyDataSetChanged();
                    }
                });
```

In RxBus of RxJava2 case:
``` java
todoStore.toObservable(TodoStore.ListChangeEvent.class)
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(
                new Consumer<TodoStore.ListChangeEvent>() {
                    @Override
                    public void accept(final TodoStore.ListChangeEvent inEvent) throws Exception {
                        TodoAdapter.super.notifyDataSetChanged();
                    }
                });
```

# Reference
[A tutorial for FluxJava](https://wznote.blogspot.com/2016/11/a-tutorial-for-fluxjava.html)

License
=======

    Copyright 2016 Bugs will find a way (https://wznote.blogspot.com)

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

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

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

repository: winzillion/FluxJava

repo_name: winzillion/FluxJava


text:
## Dataflow

Dataflow is a distributed stream-based batch processing engine for Big Data applications.
You can write tasks to be executed on a dataset. The task is then compiled into execution graphs and passed as
JSON commands to corresponding worker servers to be executed.

* Data graph consists of nodes that correspond to certain operations (e.g. Download, Filter, Map, Reduce, Sort, etc).
* User can define custom predicates, mapping functions, reducers to be executed on datasets.
* Nodes in a data graph have inputs and outputs which are identified by a unique StreamId. This allows inter-partition
data computation.
* Since nodes are stateless by themselves, computation is similar to passing data items through a pipeline, applying certain
operations during the process.


text:
# autoArm_Leg
Simple auto-rig for an IK/FK arm and reverse foot setup for legs. Undo button only "undos" the rig command if it was the last command done.

## autoArm
Must have joints labelled shoulder, elbow, and wrist (i.e. L_Shoulder, shoulder, Rshoulder).
Select clavicle or shoulder joint and then click "rig."
Arm can be rigged as IK, FK, or with an IK/FK switch.

## autoLeg
Must have joints labelled hip, knee, and ankle (i.e. L_Hip, hip, Rhip). Foot joints must be created as if the character was standing on the XY-plane, facing in the forwards Z direction.
Select hip joint and then click "rig."
Can adjust length of foot control.
This script also creates the reverse foot joints (RevHeel, RevToe, etc.), so it is preferred to specify a custom prefix.


text:
# pyvisa-mock

pyvisa-mock aims to provide similar functionality as [pyvisa-sim](https://pyvisa-sim.readthedocs.io/en/latest/), however, instead of a static YAML file providing query/response items, a dynamic python object is responsible for handling queries.

## Example

```python
from collections import defaultdict
from visa import ResourceManager
from visa_mock.base.base_mocker import BaseMocker, scpi
from visa_mock.base.register import register_resource

class MockerChannel(BaseMocker):
    """
    A mocker channel for a multi channel voltage source.
    Voltages are zero by default
    """

    def __init__(self, call_delay: float = 0.0):
        super().__init__(call_delay=call_delay)
        self._voltage = 0

    # Lets define handler functions. Notice how we can be
    # lazy in our regular expressions (using ".*"). The
    # typehints will be used to cast strings to the
    # required types

    @scpi(r":VOLT (.*)")
    def _set_voltage(self, value: float) -> None:
        self._voltage = value

    @scpi(r":VOLT\?")
    def _get_voltage(self) -> float:
        return self._voltage

class Mocker(BaseMocker):
    """
    The main mocker class.
    """

    def __init__(self, call_delay: float = 0.0):
        super().__init__(call_delay=call_delay)
        self._channels = defaultdict(MockerChannel)

    @scpi("\*IDN\?")
    def idn(self) -> str:
        """
        'vendor', 'model', 'serial', 'firmware'
        """
        return "Mocker,testing,00000,0.01"

    @scpi(r":INSTR:CHANNEL(.*)")
    def _get_channel(self, channel: int) -> MockerChannel:
        return self._channels[channel]

register_resource("MOCK0::mock1::INSTR", Mocker())

rc = ResourceManager(visa_library="@mock")
res = rc.open_resource("MOCK0::mock1::INSTR")
res.write(":INSTR:CHANNEL1:VOLT 2.3")
reply = res.query(":INSTR:CHANNEL1:VOLT?")  # This should return '2.3'
```


text:
# PSTweetChat TweetScript

## Friday, November 1, 2019

### [@PSJamesP](https://twitter.com/PSJamesP) \<James Petty\>

> [Sorry I can't make the #PSTweetChat today. Y'all have fun!](https://twitter.com/PSJamesP/status/1190180931363049472)

### [@JeffHicks](https://twitter.com/JeffHicks) \<Jeff Hicks\>

> [Chatting #PowerShell today at 1PM Eastern (5PM UTC). Use this hashtag to join in -> #PSTweetChat](https://twitter.com/JeffHicks/status/1190280584062480385)

### [@JeffHicks](https://twitter.com/JeffHicks) \<Jeff Hicks\>

> [You might want to use a tool like this  for today's #PowerShell chat because it adds the tag #pstweetchat](https://twitter.com/JeffHicks/status/1190308237926633472)

+ [http://www.tchat.io/rooms/pstweetchat](http://www.tchat.io/rooms/pstweetchat)

### [@JeffHicks](https://twitter.com/JeffHicks) \<Jeff Hicks\>

> [The dog needs some attention. If I'm not back in a few minutes start chatting without me. #pstweetchat](https://twitter.com/JeffHicks/status/1190310715174862848)

### [@BrettMiller_IT](https://twitter.com/BrettMiller_IT) \<Brett Miller\>

> [#PSTweetChat What you lovely lot been up to with #PowerShell this month. Did you get your #Hacktoberfest pull requests in?](https://twitter.com/BrettMiller_IT/status/1190313774051397634)

### [@JeffHicks](https://twitter.com/JeffHicks) \<Jeff Hicks\>

> [Pull out the candy you are hiding and join in the chat. #pstweetchat](https://twitter.com/JeffHicks/status/1190314007619653632)

### [@JeffHicks](https://twitter.com/JeffHicks) \<Jeff Hicks\>

> [I've been working on some new backup tools using #PowerShell. #pstweetchat](https://twitter.com/JeffHicks/status/1190314153900224512)

### [@JeffHicks](https://twitter.com/JeffHicks) \<Jeff Hicks\>

> [I use a number or cloud services but am paranoid about synching corrupted or infected files. #pstweetchat](https://twitter.com/JeffHicks/status/1190314239518560257)

### [@SOZDBA](https://twitter.com/SOZDBA) \<Shane O'Neill\>

> [@BrettMiller_IT Oh sheet #PSTweetchat!!! I made this one!](https://twitter.com/SOZDBA/status/1190314252923486208)

### [@JeffHicks](https://twitter.com/JeffHicks) \<Jeff Hicks\>

> [Want to give myself some recovery options. #pstweetchat](https://twitter.com/JeffHicks/status/1190314337296175105)

### [@BrettMiller_IT](https://twitter.com/BrettMiller_IT) \<Brett Miller\>

> [Got my last PR in on 30th, updating #PoshBot to use the v2 runtime of Az Functions. Got my talk accepted for @PSHSummit next year too. #PSTweetChat #Excited](https://twitter.com/BrettMiller_IT/status/1190314672261681155)

### [@JeffHicks](https://twitter.com/JeffHicks) \<Jeff Hicks\>

> [In case you missed it I hope you'll give the latest #IronScripter challenge a try.  #pstweetchat](https://twitter.com/JeffHicks/status/1190314757376675840)

+ [https://ironscripter.us/raise-the-dead-with-this-powershell-challenge/](https://ironscripter.us/raise-the-dead-with-this-powershell-challenge/)

### [@awickham](https://twitter.com/awickham) \<Andrew Wickham\>

> [I managed to pull off creating a self-service dashboard for certificates using Universal Dashboard, PSPKI, and openssl.  #PSTweetChat](https://twitter.com/awickham/status/1190315133295321088)

### [@BrettMiller_IT](https://twitter.com/BrettMiller_IT) \<Brett Miller\>

> [@awickham This shoulds awesome! #PSTweetChat](https://twitter.com/BrettMiller_IT/status/1190315283577221121)

### [@greggZ251](https://twitter.com/greggZ251) \<Gregg Lott\>

> [@BrettMiller_IT Scripting the application of mailbox retention policies against users mailboxes. There has been wailing and gnashing of teeth. You would think the world was coming to and end. #PSTweetChat](https://twitter.com/greggZ251/status/1190315418398986244)

### [@JeffHicks](https://twitter.com/JeffHicks) \<Jeff Hicks\>

> [If you haven't already, start bugging your boss to approve your ticket to the #PSHSummit  #pstweetchat](https://twitter.com/JeffHicks/status/1190315799032061960)

+ [https://events.devopscollective.org/event/powershell-devops-global-summit/](https://events.devopscollective.org/event/powershell-devops-global-summit/)

### [@awickham](https://twitter.com/awickham) \<Andrew Wickham\>

> [How do you handle storing credentials? We've been using the Windows Credential Manager quite a bit. Anyone using Azure Key Store or Hashicorp Vault? #PSTweetChat](https://twitter.com/awickham/status/1190315874999246853)

### [@JeffHicks](https://twitter.com/JeffHicks) \<Jeff Hicks\>

> [@greggZ251 @BrettMiller_IT It is always painful to take something away from an end user that they have grown used to. #PSTweetChat](https://twitter.com/JeffHicks/status/1190316104448708608)

### [@JeffHicks](https://twitter.com/JeffHicks) \<Jeff Hicks\>

> [Actually, #PSHSummit tickets are on sale NOW. I expect another sellout in even faster time than last year. #pstweetchat](https://twitter.com/JeffHicks/status/1190316496880381953)

### [@JeffHicks](https://twitter.com/JeffHicks) \<Jeff Hicks\>

> [Please be sure to include the chat hashtag as I use that to pull together a transcript. #pstweetchat](https://twitter.com/JeffHicks/status/1190317180891652098)

### [@JeffHicks](https://twitter.com/JeffHicks) \<Jeff Hicks\>

> [Transcripts from previous chats can be found at  #pstweetchat](https://twitter.com/JeffHicks/status/1190317331999842304)

+ [https://github.com/jdhitsolutions/PSTweetChat](https://github.com/jdhitsolutions/PSTweetChat)

### [@SOZDBA](https://twitter.com/SOZDBA) \<Shane O'Neill\>

> [What #PowerShell aspect are people looking forward to working with this coming month? #PSTweetChat](https://twitter.com/SOZDBA/status/1190317519489384448)

### [@JeffHicks](https://twitter.com/JeffHicks) \<Jeff Hicks\>

> [I've been experimenting with the FileSystemWatcher as part of a #PowerShell based backup tool. #pstweetchat](https://twitter.com/JeffHicks/status/1190317573675585536)

### [@JeffHicks](https://twitter.com/JeffHicks) \<Jeff Hicks\>

> [@SOZDBA regular expressions, events and JEA are on my #PowerShell plate. #pstweetchat](https://twitter.com/JeffHicks/status/1190317837149261827)

### [@awickham](https://twitter.com/awickham) \<Andrew Wickham\>

> [@SOZDBA We're investing heavily on our script and module maturity (Azure DevOps pipelines, NuGet gallery, etc.). Going to be a fun adventure. #PSTweetChat](https://twitter.com/awickham/status/1190317962537951237)

### [@twwilliams](https://twitter.com/twwilliams) \<Tommy Williams\>

> [@SOZDBA Finally digging into all the exciting things in the latest #PowerShell 7 preview. #PSTweetChat](https://twitter.com/twwilliams/status/1190318415254155264)

### [@JeffHicks](https://twitter.com/JeffHicks) \<Jeff Hicks\>

> [I learned about a new Format-Table parameter introduced in PSCore and carried through to PS 7. #pstweetchat](https://twitter.com/JeffHicks/status/1190318768079212545)

### [@JeffHicks](https://twitter.com/JeffHicks) \<Jeff Hicks\>

> [Try this in #PowerShell 7: get-process | format-table -RepeatHeader | more #pstweetchat](https://twitter.com/JeffHicks/status/1190318900640124928)

### [@wsmelton](https://twitter.com/wsmelton) \<Shawn Melton\>

> [@awickham @SOZDBA New module expected for PS7 will come in handy for credential management as well.. If it gets approved. #pstweetchat](https://twitter.com/wsmelton/status/1190319057872072705)

+ [https://github.com/PowerShell/PowerShell-RFC/pull/208](https://github.com/PowerShell/PowerShell-RFC/pull/208)

### [@JeffHicks](https://twitter.com/JeffHicks) \<Jeff Hicks\>

> [If you are going to Ignite this month what are you looking forward to? #pstweetchat](https://twitter.com/JeffHicks/status/1190319477898002433)

### [@devblackops](https://twitter.com/devblackops) \<Brandon Olin [1x Engineer]\>

> [The Discord backend for PoshBot is basically complete. A couple loose ends to finish before the v0.12.0 release! #PSTweetChat](https://twitter.com/devblackops/status/1190320194133954561)

+ [https://github.com/poshbotio/PoshBot/tree/master/PoshBot/Implementations/Discord](https://github.com/poshbotio/PoshBot/tree/master/PoshBot/Implementations/Discord)

### [@awickham](https://twitter.com/awickham) \<Andrew Wickham\>

> [@wsmelton @SOZDBA Nice, thanks! I knew it was mentioned but haven't seen it out in the wild. #PSTweetChat](https://twitter.com/awickham/status/1190320508425953282)

### [@JeffWBrown](https://twitter.com/JeffWBrown) \<Jeff Brown Tech\>

> [Is it a good/accepted practice to use Add-Member to add additional properties to objects? Use case: Get a list of files, add a new property to them, then output. Prevents recreating object and copying over properties. #pstweetchat](https://twitter.com/JeffWBrown/status/1190320966934638593)

### [@JeffHicks](https://twitter.com/JeffHicks) \<Jeff Hicks\>

> [@JeffWBrown I customize and extend objects all the time. Sometimes with Add-Member or Select-Object. To me that's the whole point of #PowerShell. #PSTweetChat](https://twitter.com/JeffHicks/status/1190322574686904325)

### [@JeffHicks](https://twitter.com/JeffHicks) \<Jeff Hicks\>

> [If you want an easy way to stay on top of #PowerShell Core or 7, try the PSReleaseTools module  #pstweetchat](https://twitter.com/JeffHicks/status/1190322875510730752)

+ [https://github.com/jdhitsolutions/PSReleaseTools](https://github.com/jdhitsolutions/PSReleaseTools)

### [@JeffHicks](https://twitter.com/JeffHicks) \<Jeff Hicks\>

> [Set a reminder for next month's chat on 6 December at 1:00PM Eastern. #pstweetchat](https://twitter.com/JeffHicks/status/1190324715166064644)

### [@JeffHicks](https://twitter.com/JeffHicks) \<Jeff Hicks\>

> [I also hope you'll test yourself with the #PowerShell challenges at  #pstweetchat](https://twitter.com/JeffHicks/status/1190326142047334400)

+ [https://ironscripter.us](https://ironscripter.us)

### [@JeffHicks](https://twitter.com/JeffHicks) \<Jeff Hicks\>

> [I'll post a transcript of today's chat later this afternoon. #pstweetchat](https://twitter.com/JeffHicks/status/1190326571896360962)

### [@frumpa](https://twitter.com/frumpa) \<Al Degutis\>

> [@JeffHicks After attending the 2019 #PSHSummit (my 2nd year) I shared a summary with my co-workers. 2 of them (plus myself) already submitted requests to attend 2020 #pstweetchat](https://twitter.com/frumpa/status/1190326639407849474)

### [@JeffHicks](https://twitter.com/JeffHicks) \<Jeff Hicks\>

> [Thanks for hanging out. Hope to see you next month. #pstweetchat](https://twitter.com/JeffHicks/status/1190327946659192832)

### [@vexx32](https://twitter.com/vexx32) \<Joel Sallow\>

> [This month's been a wild one. Two #PSSummit talks accepted, new #PSKoans releases, and 4 or 5 #PowerShell PRs submitted. Will have to start drafting outlines for the summit talks soon, I think. I might put together some blog posts to post during / after the summit. #PSTweetChat](https://twitter.com/vexx32/status/1190331049173299200)

### [@dfinke](https://twitter.com/dfinke) \<Doug Finke\>

> [PowerShellNotebook, lets you automate #PowerShell Notebooks with PowerShell at the command line, exports to Excel and more #PSTweetChat](https://twitter.com/dfinke/status/1190341859832414208)

+ [https://github.com/dfinke/PowerShellNotebook](https://github.com/dfinke/PowerShellNotebook)

### [@hansi02](https://twitter.com/hansi02) \<m t k\>

> [@BrettMiller_IT Figuring out path lengths for file share folders in use. #PSTweetChat](https://twitter.com/hansi02/status/1190359762757660672)

This transcript is based on tracking the #PSTweetchat tag. Not everyone remembers to insert the the tag so this is certainly an incomplete record. The entries are listed in order of Twitter's ID number which may not necessarily mean it is in complete chronological order.

_generated Friday, November 1, 2019 9:25:33 PM UTC_

repository: timothywarner/PSTweetChat

repo_name: timothywarner/PSTweetChat


text:
# myconnect
A social networking app for school students

To run:

You may need to update cocoapods first so run:
$sudo gem update

$pod install

Open myconnect.xcworkspace in XCode.

Please check [myconnect-app.pptx] (https://github.com/sjsucohort6/myconnect/blob/master/myconnect-app.pptx) for more details.

repository: watsh-rajneesh/myconnect-app-ios

repo_name: watsh-rajneesh/myconnect-app-ios


text:
# AppRunnerSettings.Clone method

Clones the settings.

```csharp
public AppRunnerSettings Clone()
```

## See Also

* class [AppRunnerSettings](../AppRunnerSettings.md)
* namespace [Faithlife.Build](../../Faithlife.Build.md)

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

repository: timothy-b/FaithlifeBuild

repo_name: timothy-b/FaithlifeBuild


text:
# Proteomics_Challenge
A script to find the position of each modified amino acid residue (see input.tsv) from a fasta file (see proteins.fasta)

Exercise 1: How to run?
=> python <space> sc.py <space> input.tsv <space> proteins.fasta <space> (any output file name)
an output with a successful run attached as 'checkout' file.

Exercise 2: Solution is a Python notebook attached as an HTML article and .ipynb file.


text:
### `tf.test.get_temp_dir()` {#get_temp_dir}

Returns a temporary directory for use during tests.

There is no need to delete the directory after the test.

##### Returns:

  The temporary directory.


text:
---
layout: post
title: "Predicting Animation Skeletons for 3D Articulated Models via Volumetric Nets"
date: 2019-08-22 17:26:46
categories: arXiv_CV
tags: arXiv_CV
author: Zhan Xu, Yang Zhou, Evangelos Kalogerakis, Karan Singh
mathjax: true
---

* content
{:toc}

##### Abstract
We present a learning method for predicting animation skeletons for input 3D models of articulated characters. In contrast to previous approaches that fit pre-defined skeleton templates or predict fixed sets of joints, our method produces an animation skeleton tailored for the structure and geometry of the input 3D model. Our architecture is based on a stack of hourglass modules trained on a large dataset of 3D rigged characters mined from the web. It operates on the volumetric representation of the input 3D shapes augmented with geometric shape features that provide additional cues for joint and bone locations. Our method also enables intuitive user control of the level-of-detail for the output skeleton. Our evaluation demonstrates that our approach predicts animation skeletons that are much more similar to the ones created by humans compared to several alternatives and baselines.

##### Abstract (translated by Google)

##### URL
[https://arxiv.org/abs/1908.08506](https://arxiv.org/abs/1908.08506)

##### PDF
[https://arxiv.org/pdf/1908.08506](https://arxiv.org/pdf/1908.08506)


text:
# Freenom PHP Class

This is a PHP wrapper class for the [Freenom](http://www.freenom.com) API.
It returns information in the JSON format.

More information about it can be found on the [Freenom API Page](http://www.freenom.com/en/freenom-api.html).

For information about the methods, please check `./classes/freenom.v*.class.php` files.

**!!!** Apparently, free domains cannot be registered using the API.

## Examples

Usage examples can be found in `./examples`. Please remember to edit `settings.example.php` with your credentials and save it as `settings.php`

## TODO

- add more validation to parameters than just required or not;
- add a testing component;
- improve code structure;
- add Composer compatibility;
- add XML support.


text:
# HashKraken
Demostration of the [Gishiki](https://github.com/NeroReflex/Gishiki) framework througth hash craking!

Open a terminal and issue:
```sh
git clone https://github.com/NeroReflex/HashKraken.git
cd HashKraken
vagrant up
vagrant ssh
cd /vagrant
php dictionary.php localhost dictionary_small.txt
```

Enjoy colorful text spreading all over your terminal!

## License
Released under the MIT License. Read the LICENSE file.

repository: NeroReflex/HashKraken

gha_language: PHP

repo_name: NeroReflex/HashKraken


text:
# r-ryantm {#r-ryantm}

[@r-ryantm](https://github.com/r-ryantm), is a bot account that updates Nixpkgs by making PRs that bump a package to the latest version. It runs on [community-configured infrastructure](https://github.com/nix-community/infra/tree/master/build02).

repository: ryantm/nixpkgs-update

gha_language: Haskell

repo_name: ryantm/nixpkgs-update


text:
## Links to algorithm sections

This file provides links to important sections of our entire navigation implementations.
Main local planner structures:

https://github.com/ivaROS/PotentialGap/blob/main/src/planner.cpp

https://github.com/ivaROS/PotentialGap/blob/main/src/potential_gap.cpp

### Gap detection

https://github.com/ivaROS/PotentialGap/blob/main/src/gap_manip.cpp

https://github.com/ivaROS/PotentialGap/blob/main/src/gap_utils.cpp

### Potential field construction and trajectory generation

https://github.com/ivaROS/PotentialGap/blob/main/src/gap_trajectory_generator.cpp

### Trajectory scoring

https://github.com/ivaROS/PotentialGap/blob/main/src/trajectory_scoring.cpp

### Trajectory controller with projection operator

https://github.com/ivaROS/PotentialGap/blob/main/src/trajectory_controller.cpp

## Detailed Description of Algorithms
https://github.com/ivaROS/PotentialGap/blob/main/SuppMat/gapMerging.pdf

repository: Forrest-Z/PotentialGap

repo_name: Forrest-Z/PotentialGap


text:
# Coiniac
Cryptocurrency coin miner game. Catch your coins!

## Build
First of all install [NPM](https://www.npmjs.com/) dependencies with:
```
$ npm install
```

The whole project is glued by [Gulp](https://gulpjs.com/). Run default task:
```
$ gulp
```
The build task produce `bin/game.js` file, which is linked to `index.html`.

For more information see `gulpfile.js`.

### Minify & uglify
Run:
```
$ gulp minify
```
in order to uglify and minify the built file (`bin/game.js`).

### Watch changes
Run:
```
$ gulp watch
```
in order to listen for changes in typescript files under `src/` folder and automatical rebuild.

## Run
Run any HTTP server e.g.:
```
$ php -S localhost:8080
```

## Version
Version 1.0.0.
Built by HTML5 game framework [Phaser](https://phaser.io/).

repository: hradecek/coiniac

repo_name: hradecek/coiniac


text:
# Discostromella Petr. GENUS

#### Status
SYNONYM

#### According to
Index Fungorum

#### Published in
Annls mycol. 22(1/2): 34 (1924)

#### Original name
Discostromella Petr.

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone