text:
# mxnet-text-to-image

Text to Image translation using Generative Adversarial Network and MXNet

The current project implement the following DCGAN models that can perform text-to-image translation:

* [dcgan1.py](mxnet_text_to_image/library/dcgan1.py): In this model:
    * The generator takes in a randomly generated sequence of fixed length (default to 100) and the glove-encoded text features (of fixed length
    of 300), concatenates the two and pass them through a number of layers of Conv2DTranspose to produce
    transformed images of shape (3, 224, 224) where 3 is the image channels and 224 are the width and height of
    the images.
    * The discriminator takes image features (extracted using a pretrained VGG16 model) of shape (, 1000), which
    is concatenated with the glove-encoded text features and pass through Dense layers to produce a single output
    which is passed to SigmoidBinaryCrossEntropy loss function.
* [dcgan2.py](mxnet_text_to_image/library/dcgan2.py): In this model:
    * The generator takes in a randomly generated sequence of fixed length (default to 100) and the glove-encoded text features (of fixed length
    of 300), concatenates the two and pass them through a number of layers of Conv2DTranspose to produce
    transformed images of shape (3, 64, 64) where 3 is the image channels and 64 are the width and height of
    the images.
    * The discriminator takes the (3, 64, 64) transformed images and pass them through layers of Conv2D to produce
    a fixed-length numeric vector, which is then concatenated with the glove-encoded text features and pass through
    Dense layers to produce a single output, which is passed to SigmoidBinaryCrossEntropy loss function.

Currently the DCGan in [dcgan1.py](mxnet_text_to_image/library/dcgan1.py) is computationally very intensive (in fact it failed to run on my graphics card, though runs fine on CPU). But
DCGan in [dcgan2.py](mxnet_text_to_image/library/dcgan2.py) works. To test out the DCGan in [dcgan2.py](mxnet_text_to_image/library/dcgan2.py)
with pretrained models in [demo/models](demo/models), run the following command:

```bash
python demo/dcgan2_test.py
```

# Usage

### Training

The [demo](demo) codes contains scripts on how to train the DCGAN models using the [flowers](http://www.robots.ox.ac.uk/~vgg/data/flowers/102/)
dataset.

Before the training can start, the dataset must be prepared:

Step 1: download flower dataset from : http://www.robots.ox.ac.uk/~vgg/data/flowers/102/
Step 2: extract the images and put them into the demo/data/flowers/jpg folder

The caption dataset is already included in the project in the [demo/data/flowers/text_c10](demo/data/flowers/text_c10)

Next build the image features and text features from the images and the caption dataset, run the following command:

```bash
python demo/generate_features.py
```

To train the [DCGan](mxnet_text_to_image/library/dcgan2.py) in [dcgan2.py](mxnet_text_to_image/library/dcgan2.py)
using the flowers dataset, run the following command:

```bash
python demo/dcgan2_train.py
```

Below shows the codes in the [demo/dcgan2_train.py](demo/dcgan2_train.py):

```python
import os
import sys
import mxnet as mx
import logging

LOAD_EXISTING_MODEL = False

def patch_path(path):
    return os.path.join(os.path.dirname(__file__), path)

def main():
    sys.path.append(patch_path('..'))

    logging.basicConfig(level=logging.DEBUG)

    data_dir_path = patch_path('data/flowers')
    output_dir_path = patch_path('models')
    batch_size = 64
    epochs = 100
    ctx = mx.gpu(0)

    from mxnet_text_to_image.library.dcgan2 import DCGan
    from mxnet_text_to_image.data.flowers import get_data_iter
    from mxnet_text_to_image.data.flowers_images import get_transformed_images

    train_data = get_data_iter(data_dir_path=data_dir_path,
                               batch_size=batch_size,
                               limit=10000,
                               text_mode='add')

    image_dict = get_transformed_images(data_dir_path=os.path.join(data_dir_path, 'jpg'),
                                        image_width=64, image_height=64)

    gan = DCGan(model_ctx=ctx)
    gan.random_input_size = 20  # random input is 20, text input is 300
    if LOAD_EXISTING_MODEL:
        gan.load_model(model_dir_path=output_dir_path)

    start_epoch = 0
    gan.fit(train_data=train_data, image_dict=image_dict, model_dir_path=output_dir_path,
            start_epoch=start_epoch,
            epochs=epochs, batch_size=batch_size)

if __name__ == '__main__':
    main()
```

After training, the trained models will be saved to the [demo/models](demo/models) folder with prefix "dcgan-v2-..."

### Testing trained models

To test the trained models in [demo/models], run the following command:

```bash
python demo/dcgan2_test.py
```

Below is the sample codes in [demo/dcgan2_test.py](demo/dcgan2_test.py):

```python
import os
import sys
import mxnet as mx
import logging

def patch_path(path):
    return os.path.join(os.path.dirname(__file__), path)

def main():
    sys.path.append(patch_path('..'))

    logging.basicConfig(level=logging.DEBUG)

    model_dir_path = patch_path('models')
    ctx = mx.gpu(0)

    from mxnet_text_to_image.library.dcgan2 import DCGan
    from mxnet_text_to_image.data.flowers_texts import load_texts

    gan = DCGan(model_ctx=ctx)
    gan.load_glove(glove_dir_path=patch_path('data/glove'))
    gan.load_model(model_dir_path=model_dir_path)

    texts = load_texts(patch_path('data/flowers/text_c10'), 300)
    for i, (image_id, lines) in enumerate(texts.items()):
        for j, line in enumerate(lines[:1]):
            print(line)
            gan.generate(text_message=line, output_dir_path=patch_path('output'), filename=str(i) + '-' + str(j) + '.png')

if __name__ == '__main__':
    main()

```

Some sample results are show below:

class 2 - instance 4 text: this flower has very long yellow stamen and a large white petal around it.

![](images/2-4.png)

class 4 - instance 2 text: this flower is pink and white in color, with petals that are striped with veins.

![](images/4-2.png)

class 37 - instance 8 text: this flower consists of lavender pedals with long white stamen.

![](images/37-8.png)

class 39 - instance 7 text: this flower is pink in color, and has petals that are oval shaped with veins.

![](images/39-9.png)


text:
---
breadcrumbs:
- - /chromium-os
  - Chromium OS
- - /chromium-os/testing
  - Testing Home
page_name: dynamic-test-suites
title: Dynamic Test Suites
---

## Autotest Dynamic Test Suites

The next iteration of CrOS testing in Autotest is more dynamic and requires
fewer manual changes with respect to adding and disabling tests. The first pass
at this required suites to be manually defined by hardcoding a list of tests,
and added infrastructure to find a set of machines on which to run those tests.
The former required manual management, and the latter can already be done by
appropriately using autotest. Dynamic suites, in contrast, are defined by
looking over all existing control files at runtime, and rely on the autotest
infrastructure to shard the tests across all available, appropriate machines.
As far as someone scheduling a BVT run is concerned, sending an RPC to the
autotest frontend telling it to schedule ‘control.bvt’ for a certain build on a
certain board is sufficient; all other logic exists inside of the Autotest
frontend (AFE).

### Detailed Design

#### Specifying job dependencies

#### This is how a single test specifies the kind of machine on which it can be run. DEPENDENCIES is just a list of labels. A machine satisfying all of them must be found in order for the job to be successfully scheduled.

*   #### DEPENDENCIES=‘CDMA’, ‘POWER’, ‘GOBI3K’, ‘X86’

#### All current tests need to be re-evaluated and updated to encapsulate required dependencies. e.g. GSM, CDMA, POWER, GOBI3K, BLUETOOTH etc etc. For architecture-dependent tests, we can also include labels like ARM, TEGRA2, TEGRA3, X86, etc.

#### Board compatibility

We ultimately decided against specifically expressing which boards a test should
and should not run on. We couldn’t come up with a reason we’d need to avoid a
specific board or class of boards that could not be expressed with DEPENDENCIES.
Bluetooth tests don’t apply to Alex? Well, no Alex device will have BLUETOOTH.
ACPI tests don’t apply to ARM? Well, they’ll DEPEND on x86.
Instead, we will rely on dynamic_suite code in the AFE to distinguish between a
test that has unsatisfiable dependencies at the time of scheduling, and one that
can be scheduled, but does not run in the time allotted. In the latter case, the
job will be ABORTed. In the former case, we will fail the test with TEST_NA. In
the Alex case above, for example, all tests with a BLUETOOTH dep will be
TEST_NA. As a more complicated example, consider a GOBI3K test on Mario, and
assume we have only one Mario with that modem in it. If all is well, the test
can be scheduled in the time allowed and things are good. If the device is down,
the AFE still knows that it should have a machine that meets the test’s
DEPENDENCIES, but discovers that the device is not currently ready. That’s fine,
and it schedules the test. When the time allotted for the suite is up, the test
would be ABORTed and included as a failure in the test results.

#### Job reporting

For TPM’s, one can provide a view of test results per-build-per-board that shows
all jobs that could be scheduled, and the results of those tests. Specifically,
jobs that are TEST_NA can be ignored if the customers of the dashboard
so-desire.
For the lab team, we can show all jobs that we tried to schedule, so that we can
see which jobs are getting starved and detect new, unexpected starvation.

#### Defining suites

\*\*\* For more updated information, please see the [Dynamic Suites Code
Lab](/chromium-os/testing/test-code-labs/dynamic-suite-codelab).

We've added a custom variable to control files called SUITE. SUITE can contain a
comma-delineated list of arbitrary strings. Only suite names that have an
associated control file will actually be usable in any meaningful way. By
convention, we put all suite control files in a top-level directory called
'test_suites', and name the files appropriately. For example,
`test_suites/control.bvt` is the control file for the BVT suite.

**This does require parser changes, and does make including upstream tests in
our suites a bit complex. The former is not that difficult (and probably
upstreamable). We could likely address the latter by adding a level of
control-file-indirection, and having a site-specific file that uses SUITE and
references the upstream test.**

**We use the already-existing “EXPERIMENTAL” flag to mark tests as candidates for inclusion in a suite, and will run them along with the non-experimental tests -- but tag them separately so that results can be separated out in the final report.**
**We considered making all test suites a query of sorts over the labels defined
in control files (the BVT would be all SHORT, functional tests that are not
experimental, for example), which would avoid these issues, but decided that
this smacked too much of magical side effects for use in our primary test
suites. However, we will provide a library of code that teams can use to create
their own suite control files. For example, ‘kernel.soak’ could simply be a
one-liner that found and scheduled jobs for all SHORT, MEDIUM, and LONG
functional and stress tests in the “kernel” category.**

**### The code**

**#### Scheduling a suite for a given board and image**

**We defined a new autotest RPC for this, with the following interface:**

```none
def create_suite_job(suite_name, board, build, pool, check_hosts=True,
```

```none
                     num=None, file_bugs=False, timeout=24, timeout_mins=None,
```

```none
                     priority=priorities.Priority.DEFAULT,
```

```none
                     suite_args=None, wait_for_results=True):
```

```none
    """
```

```none
    Create a job to run a test suite on the given device with the given image.
```

```none
```

```none
    When the timeout specified in the control file is reached, the
```

```none
    job is guaranteed to have completed and results will be available.
```

```none
```

```none
    @param suite_name: the test suite to run, e.g. 'bvt'.
```

```none
    @param board: the kind of device to run the tests on.
```

```none
    @param build: unique name by which to refer to the image from now on.
```

```none
    @param pool: Specify the pool of machines to use for scheduling
```

```none
            purposes.
```

```none
    @param check_hosts: require appropriate live hosts to exist in the lab.
```

```none
    @param num: Specify the number of machines to schedule across.
```

```none
    @param file_bugs: File a bug on each test failure in this suite.
```

```none
    @param timeout: The max lifetime of this suite, in hours.
```

```none
    @param timeout_mins: The max lifetime of this suite, in minutes. Takes
```

```none
                         priority over timeout.
```

```none
    @param priority: Integer denoting priority. Higher is more important.
```

```none
    @param suite_args: Optional arguments which will be parsed by the suite
```

```none
                       control file. Used by control.test_that_wrapper to
```

```none
                       determine which tests to run.
```

```none
    @param wait_for_results: Set to False to run the suite job without waiting
```

```none
                             for test jobs to finish. Default is True.
```

```none
```

```none
    @raises ControlFileNotFound: if a unique suite control file doesn't exist.
```

```none
    @raises NoControlFileList: if we can't list the control files at all.
```

```none
    @raises StageBuildFailure: if the dev server throws 500 while staging build.
```

```none
    @raises ControlFileEmpty: if the control file exists on the server, but
```

```none
                              can't be read.
```

```none
```

```none
    @return: the job ID of the suite; -1 on error.
```

```none
    """
```

```none
```

*   **Change priority:** The arg priority is an integer denoting
            priority, used by our scheduler to decide how to prioritize jobs.
            You can find all valid priority options in
            autotest_lib.client.common_lib.priorities. Currently, the priority
            ladder looks like - Weekly < Daily <PostBuild < Default
            < Build < PFQ < CQ.
*   **Wait or not wait for results:** Use the arg
            wait_for_results=True/False to tell the suite job whether you want
            it to wait for all test jobs to finish or not. Not waiting for the
            results can reduce the load burden to our rpc server, so it is
            recommended whenever it is possible.

#### Running the suite

**create_suite_job() starts by telling the dev server to fetch the image to be tested, and its associated autotest bundle, from the URL provided. Clients of autotest will no longer need to be aware of the dev server. The details of this may change going forward, but all this work will be handled by this RPC.**
**Once the image and autotest bundle are staged on dev server, it goes through all the control files associated with the build being tested, and schedule the proper jobs. At that point, we let the autotest scheduler take responsibility for all the async scheduling/dependency scheduling. It is important that all jobs are scheduled via rpc calls with a name that associates them all together so that when we want to look at results we can aggregate them all in a query. This will allow callers (like the buildbot-autotest connection) to poll for the status of all jobs kicked off by the BVT suite control file, and eventually find and gather up results for reporting purposes**

repository: iridium-browser/iridium-browser

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: iridium-browser/iridium-browser


text:
# Product Overview

About Kontext and how to get started

## What is Kontext?

Kontext enables you to integrate app analytics and marketing.

Our platform helps you increase user engagement in three ways:

- You can track actions users are taking in your app to analyze how people use your product.
- You can segment users based on their actions and run targeted campaigns to these segments.
- You can analyze each of your campaigns to understand their impact on user engagement and your business metrics.

## Platform Features

There are five parts of the Kontext platform:

- **EASY TO USE** - Implementing reliable interfaces to the GCM/FCM (Google), APNS (Apple), and the Web Push protocols is difficult. There are open source projects to do it, but even the best ones break when message quantity begins to exceed 500,000 at a time.
- **SDKs** that let you track users’ actions within your mobile apps and websites. Our SDKs also enable you to personalize your app by giving you access to user profile data.
- **DASHBOARD** where you can segment your users based on their actions, run targeted campaigns to these segments, and analyze each campaign’s performance.
- **ADVANCED FUNCTIONALITY** - Kontext provides marketing tools including A/B testing, segment targeting, variable-substitution, localization, drip marketing, and conversion tracking.
- **WEBHOOKS** that let you trigger workflows in your backend systems as soon as qualifying events occur.

## Core Concepts

Users, events, segments, campaigns, and reports are central to the Kontext experience, so it is important to understand each one's role.

- **Users:** After you integrate the Kontext SDK, a user profile will be created for each person who launches your app or visits your website. The Kontext user profile has a set of default fields, such as device and location. You can also extend the default user profile data model by adding custom fields that are specific to your business.
- **Events:** The Kontext SDK lets you track what actions users perform in your app or website, such as a user viewing a product, listening to a song, or making a purchase. Events are associated with a user profile.
 Once you’ve identified segments of interest, you can save them, target them with a campaign, and then analyze them over time.
- **Campaigns:** Kontext campaigns enable you to communicate with your users at scale. Kontext offers 3 different messaging channels to reach your users with the right message at the right time.
- **Reports:** Kontext lets you build reports to understand the impact of your campaigns on your users. You can use these reports to analyze your user engagement and guide product decisions.

## How do I get started?

1. Go to our [Android](/android-quickStart) or [iOS](ios-quickStart) setup guides to get started implementing Kontext in your product today!

license: MIT

repository: kontext-hq/documentation

repo_name: kontext-hq/documentation


text:
---
layout: post
authors: ["Kathy Chung"]
title: "What Digital Humanists Also Do"
date: 2016-05-30
time: "00:05:00"
tags: ["Digital Humanities"]
---
Following up on [an earlier post]({{site.baseurl}}/blog/2016/05/what-digital-humanists-do.html),
here are two more user stories from digital humanists
to help us figure out what they need and how we can help.

## Gamma

Gamma is a senior scholar working on two projects.
The first looks at communities of workers and architects in the Medieval and Renaissance eras,
and relies on records of specific buildings,
diaries of artisans,
sketches,
and building plans
(some of which are very large: the width of a sidewalk, and the length of a city block).
The end goal is to learn about the people who created the buildings,
who they did the work with,
the processes they used,
what they were paid,
and so on,
and more broadly to understand the social network of people involved in creating
the great buildings of the time.

Gamma spends a lot of time in archives,
copying and studying various original manuscripts
(many of which have never been digitized).
Since many of the buildings are still standing,
they can also take photographs
(which they have to do for mason's marks,
which can't be represented in any existing font).
There's a lot of textual description to keep track of,
and a lot of linkages between items as well.

## Delta

Delta studies metalwork objects used to store religious relics.
The research questions center around the designs,
which can be used to identify regions and creators.
Who saw the objects?
Who used them?
What was their sphere of influence (i.e., how far did they travel)?
What influence did they have on the design of other things (like buildings)?

This work also involves storing and managing lots of images
and the relationships between them.
There's also a lot of map work:
with 4000 objects in one collection and 5000 in another,
finding out what was where, when,
can help determine what might have influenced what.
There are a few useful databases for this,
but mostly Gamma has documents (containing text, images, and citations)
in various folders on a hard drive.

## Epsilon

Epsilon started the interview by saying, "I am hopeless with technology,"
and like many people,
has stuck to out-of-date versions of software
rather than risk breaking anything.
Their dissertation topic is the pictorial tradition for illustraing
the late Medieval story "The Three Living and the Three Dead",
which was recorded in a number of languages by different poets.
Their goal was not a comprehensive catalog of every image,
but to characterize how the image was understood in continental Europe,
and when and why differences arose between northern and southern Europe.
13th and 14th Century images tend to come with a copy of the poem;
by the 15th Century the images took on religious meanings of their own.

A growing number of these images available in Google search,
and smaller libraries are also beginning to digitize their collections,
but collecting images was still hard work, and costly
(so much so that Epsilon eventually restricted the search to France, Germany, and the Low Countries).
It was also hit and miss:
institutions might commission more detailed descriptions of items in their collections,
and even digital reproductions,
but if no textual description from an archive or museum said "three living and three dead",
those images might never turn up.

At the same time,
while it's easy enough now to take pictures with a phone,
managing those is difficult,
since there's no easy way to add annotations directly on the phone.
There is FADIS (the Fine Arts Digital Imaging System),
but it can't use it for personal research on a personal computer.

repository: swcarpentry/website

branch_name: refs/heads/main

gha_language: HTML

gha_license_id: MIT

repo_name: swcarpentry/website


text:
---
author<EMAIL_ADDRESS>comments: true
date: 2015-10-22 02:14:24+00:00
layout: post
link: http://www.econpointofview.com/2015/10/two-cheers-for-good-theory/
slug: two-cheers-for-good-theory
title: Two Cheers for (Good) Theory
wordpress_id: 1367
categories:
- Economics
tags:
- Demand
- Economics
- Supply
- Theory
---

Everyone is having a grand-ole time cheering about the "new" empirical wave of economics. Write-ups about the recent Nobel winner, Angus Deaton, have talked all about his influence on [data analysis](http://www.nytimes.com/2015/10/13/upshot/why-angus-deaton-deserved-the-economics-nobel-prize.html?_r=0):

>
> His method of careful analysis of data from household surveys has transformed four large swaths of the dismal science: microeconomics, econometrics, macroeconomics and development economics.
>
>

>
> He has brought microeconomics — traditionally a field populated by theorists — into closer connection with the data. Partly because of his influence, modern microeconomists are more likely to spend their days knee-deep in large-scale data sets describing the real-world decisions made by millions of people, and less likely to be mired in Greek-letter abstractions.
>
>

>
> Much of the empirical revolution in economics has been enabled by the tools that Mr. Deaton developed. These tools reimagine the role of economic theory, using it to organize and interpret the tidal wave of data coming from the hundreds of household surveys conducted around the world each year.
>
>

[Bloggers](http://noahpinionblog.blogspot.com/2015/09/theory-vs-data-in-economics.html) have gone nuts over it, but it's not only them. The John Bates Clark award has been heavy on the [empirical micro lately](https://afinetheorem.wordpress.com/2015/04/24/the-power-of-communication-d-rahman-2014/);

>
> (E)ssentially changing this prize from “Best Economist Under 40” to “Best Applied Microeconomist Under 40”. Of the past _seven_ winners, the only one who isn’t obviously an applied microeconomist is Levin, and yet even he [describes himself](http://web.stanford.edu/~jdlevin/) as “an applied economist with interests in industrial organization, market design and the economics of technology.”
>
>

I get it. Increased data and computational power have allowed us to do things we couldn't do 10 years ago. It has exploded.  Plus, for the blogosphere, the data turns into pretty pictures that we can all uuuhhh and aaawww at. FiveThirtyEight and others have made a whole industry out of this.

It's great. I love it.

But **theory** is ultimately the force that drives our understanding of the world. As Hayek wrote, the abstract is primary. That's why I love seeing Rakesh Vohra come to the [defense of theory](https://theoryclass.wordpress.com/2015/10/21/gradgrindian-economics/). I know; shocking that a theorist would defend theory... It's short, snarky, and spot on, as blog posts should be. (And hard to excerpt it so [read it.](https://theoryclass.wordpress.com/2015/10/21/gradgrindian-economics/))

If you'll indulge me and let another theorist try to defend the first theorist, using theory... I'll use a theory to try to think through the marginal benefits of theory and empirical work. I think Supply and Demand is a pretty useful theory for thinking through things... But I might be biased.

Let me try my best at making pretty pictures. (If FiveThirtyEight wants me to start designing charts for them, I'm available. Call me.)

Suppose because of a technology "shock" the marginal cost of empirical work declines. This causes a shift to the right of the supply curve of empirical work, lowering the marginal value of empirical work.

[![supplyshift (1)](http://www.econpointofview.com/wp-content/uploads/2015/10/supplyshift-1.png)](http://www.econpointofview.com/wp-content/uploads/2015/10/supplyshift-1.png)

This LOWERS the marginal value of empirical work. The next regression gives less value than before the technology shock.

If you believe, like I do, that empirical work and theoretical work are complements, then this should cause a shift of the marginal benefit of theoretical work. I don't think that markets adjust instantaneously, so there might be lag for the theory market to adjust to the change in the empirical market.

[![demandshift](http://www.econpointofview.com/wp-content/uploads/2015/10/demandshift.png)](http://www.econpointofview.com/wp-content/uploads/2015/10/demandshift.png)If this model gives us any insight into the markets for research, I'd say it says the exact opposite of the standard conclusion.

The marginal value of theory is now HIGHER, because of the "data" revolution. If today is between the shock and the final adjustment of theoretical work, the marginal value of the theory will continue to grow.

So I'll get back to my theory work...

repository: briancalbrecht/epv

extension: markdown

gha_language: Vue

repo_name: briancalbrecht/epv


text:
# Stockfighter C++ Client

This is a framework for a Stockfighter client in C++.

## Dependencies

These must be downloaded separately and placed in their own directories in the top-level folder:

 - [Boost](http://www.boost.org/) (into `./boost`)
 - [Websocketpp](https://github.com/zaphoyd/websocketpp) (into `./websocketpp`)

[json11](https://github.com/dropbox/json11) must also be downloaded and placed into `./sources`, and `./headers` as appropriate (only `json11.hpp` and `json11.cpp` are necessary.)

There are other dependencies (libcurl, OpenSSL, etc.) that are included by MacOS and need no further setup there.

## Building

Right now the only environment set up to build is MacOS X. The `./generate.sh` file should produce the Xcode project file, which is then used to build, run, debug, etc.

The project uses CMake so getting other environments set up should be doable. (There are some thing that will need a Windows analogue, like shell command support.)

## Usage

The game is run by passing in the stockfighter settings file:

    ./stockfighter /path/to/settings.stockfighter

The level is instantiated from within `game_t::impl_t::start`:

        engine_m.start("first_steps");

Once the instance is running, the bulk of the client boils down to two handlers (both in `./sources/game.cpp`):

 - `game_t::impl_t::world_reaction`. Code here responds to changes in the state of the world.
 - `game_t::impl_t::ticker_reaction`. Code here responds to changes in the ticker.

It helps to have one or more terminals tailing the logs and other output the client produces.

## Future Work

 - Windows build support
 - TravisCI support

 - libcurl: move to the nonblocking (`multi_`) APIs. There's even [an example](http://curl.haxx.se/libcurl/c/asiohiper.html) that uses `boost::asio` for socket handling.
 - task_queue: Add per-thread queues and task stealing
 - Improve exception handling, both in the task queue and the recurrent engine.

repository: koenigwilhelm/stockfighter

repo_name: koenigwilhelm/stockfighter


text:
# DEPRECATION NOTICE

The code in this subdirectory ("config") is likely to be deprecated soon.
It's being left here as a reference for what Spinnaker YAML config files
"look like".  It will likely be ported into a separate library specific to
the handling of Spinnaker configuration file processing (which isn't as
simple as just loading a single YAML file).

repository: armory/plank

gha_language: Go

repo_name: armory/plank


text:
# DnD 5e GraphQL API
Query D&D 5th edition SRD database with GraphQL

![Logo](http://dnd5e-graphql.com/img/logo.png?20200731)

this is a GraphQL schema built using Lumen querying a MongoDB database for all your D&D 5th edition data needs. Data is seeded from this awesome project [bagelbits/5e-database](https://github.com/bagelbits/5e-database)

Try it out here: http://dnd5e-graphql.com

## Data Issues
If you see anything wrong with the data itself, please head over to [bagelbits/5e-database](https://github.com/bagelbits/5e-database) and open an issue or PR over there.

## License

The Lumen framework is open-sourced software licensed under the [MIT license](https://opensource.org/licenses/MIT).


text:
# wx_xbee
My Xbee connected Teensy 2.0 base weather station.

# The platform consists of the following sensors:
* One-Wire Bus
 * DS2423 - Dallas Semi, One Wire dual counter. (Rain tip counter/Windspeed)
* I2C Bus
 * BMP085 - Bosch Barometric Pressure sensor.
 * SI1145 - Silicon Labs IR/UV/Visible light sensor.
 * HMC5883_U - Triple Axis compass (wind direction)
 * HTU21DF - RH sensor

# Setup
* Copy wx_xbee_config.h.dist to wx_xbee_config.h
* Edit wx_xbee_config.h with appropriate values.
* Setup the Pair of Xbee radios such that they peer when powered-up and not in sleep mode.
* Wire everything up as per the pinout below.
* Program the Teensy.

# Teensy Setup.
The teensy 2.0 must be run at 16Mhz to enable soft-serial to work. At the moment I'm powering it via +5VDC over USB to the teensy, I had grand plans to Power it via solar, but that didn't work as well as I had hoped. You can monitor activity on the teensy via the usb-serial monitor.

# The following Teensy 2.0 pins are used:
* 0  - N/U
* 1  - One-Wire pin w/ 4.7K pull-up resistor.
* 2  - N/U
* 3  - N/U
* 4  - N/U
* 5  - I2C SCL
* 6  - I2C SDA
* 7  - Serial RX
* 8  - Serial TX
* 9  - Sleep pin for Xbee Radio, Low for wake, high for sleep.
* 10 - N/U
* 11 - N/U
* 12 - N/U
* 13 - N/U
* 14 - N/U
* 15 - Xbee Serial RX
* 16 - N/U
* 17 - N/U
* 18 - N/U
* 19 - N/U
* 20 - Xbee Serial TX
* 21 - N/U
* 22 - N/U
* 23 - N/U
* 24 - N/U

# Output
The Radio output payload is sent as a set of messages. All frames start with a magic value "WX" (0x57,0x58). Next we have a Device_id , one byte (I use zero for this device). The Device_id is followed by the message type identifier, also one byte, this identifies what to expect in the payload.

The existing payload types are as follows:

* 0 - BMP
  * 32-bit float little-endian Temperature from BMP sensor.
  * 32-bit float little-endian Pressure from BMP sensor.
* 1 - RH
  * 32-bit float little-endian Temperature from RH sensor.
  * 32-bit float little-endian Humidity from RH sensor.
* 2 - Light
  * 32-bit float little-endian Viz from light sensor.
  * 32-bit float little-endian IR from light sensor.
  * 32-bit float little-endian UV from light sensor.
* 3 - Compass
  * 32-bit float little-endian Mag from compass X sensor.
  * 32-bit float little-endian Mag from compass Y sensor.
  * 32-bit float little-endian Mag from compass Z sensor.
* 4 - DS223 Counter
  * 32-bit little-endian integer Counter 1
  * 32-bit little-endian integer Counter 2
* 5 - Tilt and declination adjusted headings.
  * 32-bit float little-endian Mag from XZ.
  * 32-bit float little-endian Mag from YZ.
  * 32-bit float little-endian Mag from XY.
* 6 - Errors/Cycles
  * 32-bit little-endian integer Cycle count.
  * 32-bit little-endian integer TX Error count.

# TODO
* Schematic/wiring diagram + pictures.
* Add soil moisture/temp
* Add Visibility
* Add Snow depth
* Add Giger counter
* Add Seismometer.
* Add Lightning counter


text:
---
layout: page
title: "Apache Jackrabbit - Custom Node Types"
date: 2013-09-13 17:09
comments: true
sharing: true
footer: true
indexer: true
---
The purpose of this lab is to enhance our [previous tutorial](/labs-and-tutorials/apache-jackrabbit/querying-nodes). In that tutorial we learned how to query elements that were stored in the repository used SQL2 and JDOM. Up to now, we have been mostly dealing with unstructured nodes. This means the node themselves have no schema except for what the nt:unstructured types provided for us.

This tutorial will show how to create a custom node type and load it into the repository programmatically.

## Audience
The core audience is seated in a classroom environment. Readers performing this tutorial have just finished previous tutorials and should be familiar with how the labs will work. Most will be at work or seated in a place where they can read from the tutorial page and code in their own editor.

##Overview
In most cases, storing content will just require a node and property structure that is flexible. Node properties can differ from other node properties etc. There may come a time, however, that you want to create a schema and enforce some contraints against it, so that nodes inserted into the JCR will mandatorily have specific properties with specific types. The JSR refers to these as node type definitions.

Node types are defined using a special notation called Compact Node Type Definition Notation (or CND Notation for short). We don't have time in a single tutorial to go over the whole specification but if your interested the JSR-173 or 280 is a good place to start. There are lots of details on the grammar and usage in the specification.

Lastly, if you came directly into this tutorial and didn't do the last one, don't fret. The starter project is on GitHub and the most recent tutorial can be found working the branch lab5-nodetypes. The following clone should get you started from where we left off:

``` bash Getting The Previous Lab https://github.com/PlasmaTrout/jackrabbit-training-lab1 GitHub
git clone git@github.com:PlasmaTrout/jackrabbit-training-lab1.git
git checkout lab5-nodetypes
```

## A Quick Note Before We Get Started
I am going to have you delete the repository directory multiple times during this tutorial. In truth it's laziness, but registering node types is somewhat like building a table schema. It would be easier to have you delete it each time than issue alter statements and/or deal with dependency issues. You can however argue some options into the CndImporter command (that you will see later) and have it replace the schema each time, but this only scales so far and eventually you will cause a change that will break the semantics of the node type and it will throw an exception.

## Create A Compact Node Type Definition
In our example we are just going to create a small example to demonstrate how the definition language works. Let's say we have an node that's going to represent an article. We don't care how many properties is has, but it must have a headline and body filled out.

Let's create a file in the root of the project called article.cnd. In its contents lets write the following:

```
<ca = 'http://www.codeaffectionado.com/training'>
[ca:article]
- ca:headline (string)
mandatory
- ca:body (string)
mandatory
```

This file is going to create a namespace for our node, then declaring a new type named ca:article. This type has two mandatory properties: headline and body.

## Registering A Node Type Into The Repository
In order to use our node type in Jackrabbit, we must first register it. To do so lets clear out our try block from the previous example and add some code:

```java Registering A Node Type From A CND File
CndImporter.registerNodeTypes(new FileReader("article.cnd"),session);
```

Now lets write some test code to see what happens if we create an article but leave out the mandatory fields.

```java Adding, Viewing and Removing Our Node
Node root = session.getRootNode();
Node articles = root.addNode("articles");
Node newNode = articles.addNode("article","ca:article");

// What do you think happens?

session.save();

// Look at our node
Node savedNode = root.getNode("articles/article");
dumpToConsole(savedNode);

// Cleanup
savedNode.remove();
session.save();
```

If we *mvn compile exec:java* we should get an exception now like:

```bash Exception
javax.jcr.nodetype.ConstraintViolationException: /articles/article: mandatory property {http://www.codeaffectionado.com/training}body does not exist
```

Let's modify the last few lines and add a body and see what happens:

```java Setting A Mandatory Property Our New Node Type
Node newNode = articles.addNode("article","ca:article");
newNode.setProperty("ca:body","Hello World!");

// Now what do you think happens?

session.save();
```

Now we see another exception:

```bash Exception
javax.jcr.nodetype.ConstraintViolationException: /articles/article: mandatory property {http://www.codeaffectionado.com/training}headline does not exist
```

If we add a headline we should be ok so lets add the line:

```java Adding The Final Mandatory Property
newNode.setProperty("ca:headline","New Hello World Article");
```

And run it again, you should see the output:

```bash Sample Output
/articles/article
/articles/article/ca:body=Hello World!
/articles/article/ca:headline=New Hello World Article
/articles/article/jcr:primaryType=ca:article
```

After your done playing, *delete your repository folder* and try the next example.

## Creating Default Values
Maybe we wish to allow users to save articles that have no headline or body, but put in a default value instead. In order to do this, we need to revisit our node definition and change it to look like:

```bash New Node Type With Default Fields
<ca = 'http://www.codeaffectionado.com/training'>
[ca:article]
- ca:headline (string)
= 'Headline Goes Here'
mandatory autocreated
- ca:body (string)
= 'Body Goes Here'
mandatory autocreated
```

Now if we run this on a fresh repository (by deleting the old repository folder before running) we will see:

```bash Sample Output
/articles/article
/articles/article/ca:body=Body Goes Here
/articles/article/ca:headline=Headline Goes Here
/articles/article/jcr:primaryType=ca:article
```

## Adding Non Specified Properties To Our New Type
You may notice, if you play around, that if you try to add properties that aren't in the CND file into your node they will thrown an exception. This is because we never told the node definition that other properties are allowed. At the bottom of the file add:

```bash Allow Wildcard Sibling Properties
- * (undefined)
```

Then you will be able to. Lets delete our repository add this line and then add some java code like:

```java Set A Sibling Property
newNode.setProperty("otherProp","Yah! It Worked!");
```

Then when we run we will see:

```bash Sample Output
/articles/article
/articles/article/ca:body=Body Goes Here
/articles/article/otherProp=Yah! It Worked!
/articles/article/ca:headline=Headline Goes Here
/articles/article/jcr:primaryType=ca:article
```

## Repository Storage Of Node Types
If you want to see the fruits of your labor so far, find the custom node types xml file in the directory repository -> repository -> nodetypes -> custom_nodetypes.xml. If you look closely you can see your namespace declaration and a special system specific format for declaring what you put in the CND file.

```xml custom_nodetypes.xml
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<nodeTypes xmlns:ca="http://www.codeaffectionado.com/training" xmlns:fn="http://www.w3.org/2005/xpath-functions"
           xmlns:fn_old="http://www.w3.org/2004/10/xpath-functions" xmlns:jcr="http://www.jcp.org/jcr/1.0"
           xmlns:mix="http://www.jcp.org/jcr/mix/1.0" xmlns:nt="http://www.jcp.org/jcr/nt/1.0" xmlns:rep="internal"
           xmlns:sv="http://www.jcp.org/jcr/sv/1.0" xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <nodeType hasOrderableChildNodes="false" isAbstract="false" isMixin="false" isQueryable="true" name="ca:article"
              primaryItemName="">
        <supertypes>
            <supertype>nt:base</supertype>
        </supertypes>
        <propertyDefinition autoCreated="true" isFullTextSearchable="true" isQueryOrderable="true" mandatory="true"
                            multiple="false" name="ca:headline" onParentVersion="COPY" protected="false"
                            requiredType="String">
            <defaultValues>
                <defaultValue>Headline Goes Here</defaultValue>
            </defaultValues>
        </propertyDefinition>
        <propertyDefinition autoCreated="true" isFullTextSearchable="true" isQueryOrderable="true" mandatory="true"
                            multiple="false" name="ca:body" onParentVersion="COPY" protected="false"
                            requiredType="String">
            <defaultValues>
                <defaultValue>Body Goes Here</defaultValue>
            </defaultValues>
        </propertyDefinition>
        <propertyDefinition autoCreated="false" isFullTextSearchable="true" isQueryOrderable="true" mandatory="false"
                            multiple="false" name="*" onParentVersion="COPY" protected="false"
                            requiredType="undefined"/>
    </nodeType>
</nodeTypes>
```

Now you may ask, can't I use edit this file? I wouldn't suggest it, this file is processed on startup of the repository and could seriously damage your workspace if you made errors in it. It's best to leave the registration to the API.

## Resources

Heres our final CND file:

```bash Final CND File
<ca = 'http://www.codeaffectionado.com/training'>
[ca:article]
- ca:headline (string)
= 'Headline Goes Here'
mandatory autocreated
- ca:body (string)
= 'Body Goes Here'
mandatory autocreated
- * (undefined)
```

And our final main method:

```java Final Main Method
public static void main( String[] args ) throws Exception {
	Repository repository = new TransientRepository();
	Session session = repository.login(
			new SimpleCredentials("admin","admin".toCharArray()));

	try{
		CndImporter.registerNodeTypes(new FileReader("article.cnd"),session,true);

		Node root = session.getRootNode();
		Node articles = root.addNode("articles");
		Node newNode = articles.addNode("article","ca:article");
		newNode.setProperty("otherProp","Yah! It Worked!");
		//newNode.setProperty("ca:body","Hello World!");
		//newNode.setProperty("ca:headline","New Hello World Article");

		session.save();

		Node savedNode = root.getNode("articles/article");
		dumpToConsole(savedNode);

		savedNode.remove();
		session.save();

	}finally{
		session.logout();
	}
}
```

repository: PlasmaTrout/code-affectionado-site

repo_name: PlasmaTrout/code-affectionado-site


text:
# Reference counting

In order to release unused memory allocations, count references is a pretty good mechanism, it is also easier than multi state garbage collectors. To implement it, it is necessary to add a header to every dynamic allocation. The header will be prepended to the allocated size and remain aligned to 16 bytes. The size of the header will be 16 bytes too. The returned ref will be the `address + header_size`

The allocation algorithm will be modified as follows:

```diff
    // pseudo

    fun malloc(size): ref = {
      val ptr = malloc(size + 16)
+     setUpHeader(ptr, size)
+     ref(ptr + 16)
-     ref(ptr)
    }

+   fun setUpHeader(ptr, size) = {
+     // write allocation size in ptr
+   }
```

## Header

The header will contain information about the size of the allocation and the reference counter.

## Counting references

The algorithm uses two functions: `retain(ref)` and `release(ref)`. `retain` increments the reference counter by one. `release` decrements the reference counter by one.

The functions are located in the module `system::core::rtti`

## Scopes

A list of retained references will be added to the scopes. A statement to release all the retained references of the scope will be generated and called whenever the scope is left.

## Heuristics about reference counting

- If `retain` or `release` receive static allocations (strings or nullary structs) a short circuit is triggered.
- Allocators DO NOT call to `retain`
- Setters call to `release(old)` and `retain(new)`
- Variable assignations call to `release(old)` and `retain(new)`
- Variable declarations call `retain(value)`
- Variable declarations are registered in the current scope
- At the end of the scope a `release(V) for each declaration V in SCOPE` must be executed
- When a `break` or `continue` is executed, the code to release the variables of the scopes up until the loop declaration's scope (not inclusive) must be called
- BlockNode now produce scopes
- IfNode branches now produce new scopes
- MatcherNode now produce scopes
- Entering a function will retain every argument, leaving the function will release every argument

repository: lys-lang/lys

gha_language: TypeScript

repo_name: lys-lang/lys


text:
# FastViromeExplorer-annotate
Get functional annotation of proteins from scaffolds.

# Installation
FastViromeExplorer requires the following tools installed in the user's machine.
1. bbmap
2. Blast
3. Prodigal

## Download FastViromeExplorer-annotate
You can download FastViromeExplorer-annotate directly from github and extract it. You can also download it using the following command:
```bash
git clone https://github.com/saima-tithi/FVE-annotate.git
```
From now on, we will refer the FastViromeExplorer-annotate directory in the user's local machine as `project directory`. The `project directory` will contain 3 folders: src, bin, and tools-linux.

For installing the tool dependencies, add the following lines in the .bashrc. Please make sure to change the "path-to-project-directory" into the correct path of FastViromeExplorer-novel project directory.

```bash
#Install bbmap
export PATH=$PATH:/path-to-project-directory/tools-linux/bbmap
#Install Blast
export PATH=$PATH:/path-to-project-directory/tools-linux/ncbi-blast-2.7.1+/bin
#Install Prodigal
export PATH=$PATH:/path-to-project-directory/tools-linux/Prodigal
```

# Run FastViromeExplorer-annotate
Run FastViromeExplorer and FastViromeExplorer-novel to generate final-scaffolds.fasta file.

Download the blast non-redundant protein database using the following commands:
```bash
mkdir blast-db-directory
cd /path-to-blast-db-directory
wget 'ftp://ftp.ncbi.nlm.nih.gov/blast/db/nr.*.tar.gz'
cat nr.*.tar.gz | tar -zxvi -f - -C .
```

Then run FastViromeExplorer-annotate using the following commands:
```bash
mkdir /path-to-results/FVE-annotate-outputDirectory
cd FVE-annotate-project-directory
javac -d bin src/*.java
java -cp bin FVEAnnotate -in /path-to-FVE-novel-results/final-scaffolds.fasta -blastDbDir /path-to-blast-db-directory -o /path-to-results/FVE-annotate-outputDirectory
```

# Output
The ouput folders and files will be generated in the `FVE-annotate-outputDirectory` folder. For each scaffold in final-scaffolds.fasta, a output directory containing prodigal output and blastp output will be generated.

The output files are:
1. *scaffold-num-proteins.faa* : predicted proteins from this scaffold.
2. *blastp-output.txt* : Output of Blastp tool from aligning the proteins from this scaffold against blast non-redundant protein database.

repository: saima-tithi/FVE-annotate

repo_name: saima-tithi/FVE-annotate


text:
# polylongdiv-tex
Perform polynomial long division using modular arithmetic and output well-formatted LaTeX.

You can find action shots in the `samples` folder.

Please note that this is an *alpha version* and subject to change without notice.

## License
numsgps-sage is released under the terms of the [MIT license](https://tldrlegal.com/license/mit-license).  The MIT License is simple and easy to understand and it places almost no restrictions on what you can do with this software.

## Usage
To set up your machine to use polylongdiv-tex, do the following.

* Download and unzip polylongdiv-tex.
* Alternatively, simply download the polylongdiv.py file.
* It does not need to be placed in any particular location on your computer

To use polylongdiv-tex, use your favorite Python interpreter, or open the command prompt and run the following commands (replace `PATH_TO_POLYLONGDIV_TEX` with the path of whichever folder contains `staircase.py`).

	cd PATH_TO_POLYLONGDIV_TEX
	python polylongdiv.py --help
	python polylongdiv.py -a 1 3 -7 0 5 4  -b 2 1 5  -n 11
	python polylongdiv.py -t -a 1 3 -7 0 5 4  -b 2 1 5  -n 11
	python polylongdiv.py -t -V y -a 1 3 -7 0 5 4  -b 2 1 5  -n 11
	python polylongdiv.py -t -o myfile.txt -a 1 3 -7 0 5 4  -b 2 1 5  -n 11


text:
# Data Platform Blueprint 1 with Kafka-Spark-Solr

Enterprise applications increasingly rely on large amounts of data, that needs be distributed, processed, and stored.
Open source and commercial supported software stacks are available to implement a data platform, that can offer
common data management services, accelerating the development and deployment of data hungry business applications.

This Helm chart enables the fully automated Kubernetes deployment of such multi-stack data platform, covering the following software components:

-   Apache Kafka – Data distribution bus with buffering capabilities
-   Apache Spark – In-memory data analytics
-   Solr – Data persistence and search

These containerized stateful software stacks are deployed in multi-node cluster configurations, which is defined by the
Helm chart blueprint for this data platform deployment, covering:

-   Pod placement rules – Affinity rules to ensure placement diversity to prevent single point of failures and optimize load distribution
-   Pod resource sizing rules – Optimized Pod and JVM sizing settings for optimal performance and efficient resource usage
-   Default settings to ensure Pod access security
-   Optional Wavefront Observability framework configuration

In addition to the Pod resource optimizations, this blueprint is validated and tested to provide Kubernetes node count and sizing recommendations [(see Kubernetes Cluster Requirements)](#kubernetes-cluster-requirements) to facilitate cloud platform capacity planning. The goal is optimize the number of required Kubernetes nodes in order to optimize server resource usage and, at the same time, ensuring runtime and resource diversity.

The first release of this blueprint defines a small size data platform deployment, deployed on 3 Kubernetes application nodes with physical diverse underlying server infrastructure.

Use cases for this small size data platform setup include: data and application evaluation, development, and functional testing.

## TL;DR

```console
$ helm repo add bitnami https://charts.bitnami.com/bitnami
$ helm install my-release bitnami/dataplatform-bp1
```

## Introduction

This chart bootstraps Data Platform Blueprint-1 deployment on a [Kubernetes](http://kubernetes.io) cluster using the [Helm](https://helm.sh) package manager.

The "Small" size data platform in default configuration deploys the following:
1. Zookeeper with 3 nodes to be used for both Kafka and Solr
2. Kafka with 3 nodes using the zookeeper deployed above
3. Solr with 2 nodes using the zookeeper deployed above
4. Spark with 1 Master and 2 worker nodes

The data platform can be optionally deployed with the wavefront observability framework. In that case, the wavefront collectors will be set up as a DaemonSet to collect the Kubernetes cluster metrics to enable runtime feed into the Tanzu Observability service. It will also be pre-configured to scrape the metrics from the Prometheus endpoint that each application (Kafka/Spark/Solr) emits the metrics to.

Bitnami charts can be used with [Kubeapps](https://kubeapps.com/) for deployment and management of Helm Charts in clusters. This Helm chart has been tested on top of [Bitnami Kubernetes Production Runtime](https://kubeprod.io/) (BKPR). Deploy BKPR to get automated TLS certificates, logging and monitoring for your applications.

## Prerequisites

- Kubernetes 1.12+
- Helm 3.1.0
- PV provisioner support in the underlying infrastructure

## Kubernetes Cluster requirements

Below are the minimum Kubernetes Cluster requirements for "Small" size data platform:

| Data Platform Size | Kubernetes Cluster Size                                                      | Usage                                                                       |
|:-------------------|:-----------------------------------------------------------------------------|:----------------------------------------------------------------------------|
| Small              | 1 Master Node (2 CPU, 4Gi Memory)
 3 Worker Nodes (4 CPU, 32Gi Memory) | Data and application evaluation, development, and functional testing
 |

## Installing the Chart

To install the chart with the release name `my-release`:

```console
$ helm repo add bitnami https://charts.bitnami.com/bitnami
$ helm install my-release bitnami/dataplatform-bp1
```

These commands deploy Data Platform on the Kubernetes cluster in the default configuration. The [Parameters](#parameters) section lists recommended configurations of the parameters to bring up an optimal and resilient data platform. Please refer the individual charts for the remaining set of configurable parameters.

> **Tip**: List all releases using `helm list`

## Uninstalling the Chart

To uninstall/delete the `my-release` deployment:

```console
$ helm delete my-release
```

The command removes all the Kubernetes components associated with the chart and deletes the release.

## Parameters

The following tables lists the recommended configurations for each application used in the data platform. If you need to configure any other parameters apart from the ones mentioned below, you can refer to the corresponding chart and update the values.yaml accordingly.

### Global parameters

| Parameter                 | Description                                     | Default                                                 |
|:--------------------------|:------------------------------------------------|:--------------------------------------------------------|
| `global.imageRegistry`    | Global Docker image registry                    | `nil`                                                   |
| `global.imagePullSecrets` | Global Docker registry secret names as an array | `[]` (does not add image pull secrets to deployed pods) |
| `global.storageClass`     | Global storage class for dynamic provisioning   | `nil`                                                   |

### Zookeeper chart parameters

Parameters below are set as per the recommended values, they can be overwritten if required.

| Parameter                      | Description                                                                     | Default                                                                              |
|:-------------------------------|:--------------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|
| `zookeeper.enabled`            | Switch to enable or disable the Zookeeper helm chart                            | `true`                                                                               |
| `zookeeper.replicaCount`       | Number of Zookeeper nodes                                                       | `3`                                                                                |
| `zookeeper.heap`               | Zookeepers's Java Heap size                                                     | Zookeeper Java Heap size set for optimal resource usage                              |
| `zookeeper.resources.limits`   | The resources limits for Zookeeper containers                                   | `{}`                                                                                |
| `zookeeper.resources.requests` | The requested resources for Zookeeper containers for a small kubernetes cluster | Zookeeper pods Resource requests for optimal resource usage size                     |
| `zookeeper.affinity`           | Affinity for pod assignment                                                     | Zookeeper pods Affinity rules for best possible resiliency (evaluated as a template) |

### Kafka chart parameters

Parameters below are set as per the recommended values, they can be overwritten if required.

| Parameter                   | Description                                                                 | Default                                                                              |
|:----------------------------|:----------------------------------------------------------------------------|:-------------------------------------------------------------------------------------|
| `kafka.enabled`             | Switch to enable or disable the Kafka helm chart                            | `true`                                                                               |
| `kafka.replicaCount`        | Number of Kafka nodes                                                       | `3`                                                                                |
| `kafka.heapOpts`            | Kafka's Java Heap size                                                      | Kafka Java Heap size set for optimal resource usage                                  |
| `kafka.resources.limits`    | The resources limits for Kafka containers                                   | `{}`                                                                                |
| `kafka.resources.requests`  | The requested resources for Kafka containers for a small kubernetes cluster | Kafka pods Resource requests set for optimal resource usage                          |
| `kafka.affinity`            | Affinity for pod assignment                                                 | Kafka pods affinity rules set for best possible resiliency (evaluated as a template) |
| `kafka.metrics.kafka.enabled`  | Whether or not to create a standalone Kafka exporter to expose Kafka metrics                          | `false`                                                 |
| `kafka.metrics.kafka.resources.requests`       | Kafka Exporter container resource requests              | Kafka Exporter pod resource requests set for optimal resource usage      |
| `kafka.metrics.kafka.service.port`               | Kafka Exporter Prometheus port                                                                                | `9308`    |
| `kafka.metrics.jmx.enabled`                      | Whether or not to expose JMX metrics to Prometheus                                                                                | `false`   |
| `kafka.metrics.jmx.resources.requests`           | JMX Exporter container resource requests                  | JMX exporter pod resource requests set for best possible resiliency    |
| `kafka.metrics.jmx.service.port`                 | JMX Exporter Prometheus port                                                                                | `5556`    |
| `kafka.zookeeper.enabled`   | Switch to enable or disable the Zookeeper helm chart                        | `false` Common Zookeeper deployment used for kafka and solr                          |
| `kafka.externalZookeeper.servers` | Server or list of external Zookeeper servers to use                         | Zookeeper installed as a subchart to be used                                         |

### Solr chart parameters

Parameters below are set as per the recommended values, they can be overwritten if required.

| Parameter                        | Description                                         | Default                                                                             |
|:---------------------------------|:----------------------------------------------------|:------------------------------------------------------------------------------------|
| `solr.enabled`                   | Switch to enable or disable the Solr helm chart     | `true`                                                                              |
| `solr.replicaCount`              | Number of Solr nodes                                | `2`                                                                                |
| `solr.authentication.enabled`    | Enable Solr authentication                          | `true`                                                                              |
| `solr.resources.limits`          | The resources limits for Solr containers            | `{}`                                                                                |
| `solr.resources.requests`        | The requested resources for Solr containers         | Solr pods resource requests set for optimal resource usage                          |
| `solr.javaMem`                   | Java memory options to pass to the Solr container   | Solr Java Heap size set for optimal resource usage                                  |
| `solr.heap`                      | Java Heap options to pass to the solr container     | `nil`                                                                               |
| `solr.affinity`                  | Affinity for Solr pods assignment                   | Solr pods Affinity rules set for best possible resiliency (evaluated as a template) |
| `solr.exporter.enabled`          | Start a prometheus exporter                         | `false`                                                                             |
| `solr.exporter.port`             | Solr exporter port                                  | `9983`                                                                              |
| `solr.exporter.resources`        | Exporter resource requests/limit                    | Solr exporter pod resource requests for optimal resource usage size                 |
| `solr.exporter.affinity`         | Affinity for Solr pods assignment                   | Solr exporter pod affinity rules for best possible resiliency (evaluated as a template) |
| `solr.zookeeper.enabled`         | Enable Zookeeper deployment. Needed for Solr cloud. | `false` common zookeeper used between kafka and solr                                |
| `solr.externalZookeeper.servers` | Servers for an already existing Zookeeper.          | Zookeeper installed as a subchart to be used                                        |

### Spark chart parameters

Parameters below are set as per the recommended values, they can be overwritten if required.

| Parameter                   | Description                                      | Default                                                                                |
|:----------------------------|:-------------------------------------------------|:--------------------------------------------------------------------------------------------|
| `spark.enabled`             | Switch to enable or disable the Spark helm chart | `true`                                                                                |
| `spark.master.webPort`      | Specify the port where the web interface will listen on the master                                                                  | `8080`   |
| `spark.master.affinity`     | Spark master affinity for pod assignment         | Spark master pod Affinity rules set for best possible resiliency (evaluated as a template)  |
| `spark.master.resources`    | CPU/Memory resource requests/limits for Master   | Spark master pods resource requests set for optimal resource usage                          |
| `spark.worker.replicaCount` | Set the number of workers                        | `2`                                                                                |
| `spark.worker.webPort`      | Specify the port where the web interface will listen on the worker                                                                         | `8081`    |
| `spark.worker.javaOptions`  | Set options for the JVM in the form `-Dx=y`      | No default                                                                                |
| `spark.worker.affinity`     | Spark worker affinity for pod assignment         | Spark worker pods Affinity rules set for best possible resiliency (evaluated as a template) |
| `spark.worker.resources`    | CPU/Memory resource requests/limits for worker   | Spark worker pods resource requests set for optimal resource usage                          |
| `spark.metrics.enabled`     | Start a side-car prometheus exporter                                                                                | `false`       |
| `spark.metrics.masterAnnotations`       | Annotations for enabling prometheus to access the metrics endpoint of the master nodes  | `{prometheus.io/scrape: "true", prometheus.io/path: "/metrics/", prometheus.io/port: "8080"}` |
| `spark.metrics.workerAnnotations`       | Annotations for enabling prometheus to access the metrics endpoint of the worker nodes   | `{prometheus.io/scrape: "true", prometheus.io/path: "/metrics/", prometheus.io/port: "8081"}` |
| `spark.metrics.resources.requests` | The requested resources for the metrics exporter container  | Spark exporter container resource requests for optimal resource usage size|

### Wavefront chart parameters

| Parameter                                  | Description                                                                                | Default                                                 |
|--------------------------------------------|------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------|
| `wavefront.enabled`                        | Switch to enable or disable the Wavefront helm chart                                                                   | `true`                                                  |
| `wavefront.clusterName`                    | Unique name for the Kubernetes cluster (required)                                                                      | `KUBERNETES_CLUSTER_NAME`                               |
| `wavefront.wavefront.url`                  | Wavefront URL for your cluster (required)                                                                              | `https://YOUR_CLUSTER.wavefront.com`                    |
| `wavefront.wavefront.token`                | Wavefront API Token (required)                                                                                | `YOUR_API_TOKEN`                                        |
| `wavefront.wavefront.existingSecret`       | Name of an existing secret containing the token                                                                        | `nil`                                                   |
| `wavefront.collector.discovery.enabled`    | Rules based and Prometheus endpoints auto-discovery                                                                    | `true`                                                  |
| `wavefront.collector.discovery.enableRuntimeConfigs` | Enable runtime discovery rules                                                                               | `true`                                                 |
| `wavefront.collector.discovery.config`     | Configuration for rules based auto-discovery                                                                           | Data Platform components pods discovery config                                                   |
| `wavefront.collector.resources.limits`     | The resources limits for the collector container                                                                       | `{}`                                                    |
| `wavefront.collector.resources.requests`   | The requested resources for the collector container                                                                    | Collectors pods resource requests for optimal resource usage size                       |
| `wavefront.proxy.resources.limits`         | The resources limits for the proxy container                                                                           | `{}`                                                    |
| `wavefront.proxy.resources.requests`       | The requested resources for the proxy container                                                                        | Proxy pods resource resource requests for optimal resource usage size                                |

Specify each parameter using the `--set key=value[,key=value]` argument to `helm install`. For example,

```console
$ helm install my-release \
  --set kafka.replicaCount=3 \
  bitnami/dataplatform-bp1
```

The above command deploys the data platform with Kafka with 3 nodes (replicas).

In case you need to deploy the data platform with Wavefront Observability Framework for all the applications (Kafka/Spark/Solr) in the data platform, you can specify the 'enabled' parameter using the `--set <component>.metrics.enabled=true` argument to `helm install`. For Solr, the parameter is `solr.exporter.enabled=true` For Example,

```console
$ helm install my-release bitnami/dataplatform-bp1 \
    --set kafka.metrics.kafka.enabled=true \
    --set kafka.metrics.jmx.enabled=true \
    --set spark.metrics.enabled=true \
    --set solr.exporter.enabled=true \
    --set wavefront.enabled=true \
    --set wavefront.clusterName=<K8s-CLUSTER-NAME> \
    --set wavefront.wavefront.url=https://<YOUR_CLUSTER>.wavefront.com \
    --set wavefront.wavefront.token=<YOUR_API_TOKEN>
```

Alternatively, a YAML file that specifies the values for the above parameters can be provided while installing the chart. For example,

```console
$ helm install my-release -f values.yaml bitnami/dataplatform-bp1
```

> **Tip**: You can use the default [values.yaml](values.yaml)

## Configuration and installation details

### [Rolling VS Immutable tags](https://docs.bitnami.com/containers/how-to/understand-rolling-tags-containers/)

It is strongly recommended to use immutable tags in a production environment. This ensures your deployment does not change automatically if the same tag is updated with a different image.

Bitnami will release a new chart updating its containers if a new version of the main container, significant changes, or critical vulnerabilities exist.

## Troubleshooting

Find more information about how to deal with common errors related to Bitnami’s Helm charts in [this troubleshooting guide](https://docs.bitnami.com/general/how-to/troubleshoot-helm-chart-issues).

In order to render complete information about the deployment including all the sub-charts, please use --render-subchart-notes flag while installing the chart.

## Upgrading

### To 1.0.0

This version updates the wavefront dependency to `2.x.x` where wavefront started to use a scratch image instead of debian. This can affect a current deployment if wavefront commands were provided. From now on, the only command that you will be able to execute inside the wavefront pod will be `/wavefront-collector`.

repository: guenaelgonnord/charts

gha_language: Smarty

gha_license_id: NOASSERTION

repo_name: guenaelgonnord/charts


text:
bullshit-paper
==============

# Run

You have to have [maven](http://maven.apache.org) and git. Simply clone:

```
git clone https://github.com/neojski/bullshit-paper
```

Then you can use just maven stuff to install dependencies:

```
mvn package
```

It also runs tests. In case you're changing something tests can be fired with
`mvn test`. (use `-Dtest=bullshit_paper.NameOfTest` to run single test)

To make JavaFX work you need to have the latest version of Java and add jfxrt.jar to the local maven repository:
```
mvn install:install-file -Dfile="C:\Program Files\Java\jre7\lib\jfxrt.jar" -DgroupId=com.oracle -DartifactId=javafx -Dversion=2.2.45 -Dpackaging=jar
```

# Dict
To use the `Dict` class you have to download the dictionary from
[sjp](http://sjp.pl/slownik/odmiany) and then convert it to utf8:

```
iconv -f WINDOWS-1250 -t utf-8 odm.txt > odm
```

It is necessary to have this file in unix endlines format. You can get help on
this
[here](http://www.cyberciti.biz/faq/howto-unix-linux-convert-dos-newlines-cr-lf-unix-text-format)

Once you're done just throw it into the resources directory for dictionary (`/bullshit-paper/src/main/resources/dict`)

# Run project with GUI

You need JavaFX to do it. Download from: http://www.oracle.com/technetwork/java/javafx/downloads/index-jsp-136193.html

Then install like above:
```
mvn install:install-file -Dfile="[path_to_jfxrt_jar]" -DgroupId=com.oracle -DartifactId=javafx -Dversion=2.2.45 -Dpackaging=jar
```
where path_to_jfxrt_jar is for example C:\Program Files\Java\jre7\lib\jfxrt.jar

Last thing to do - run the project using
`make run`
in the top directory of the project.

repository: jakubbrzeski/bullshit-paper

repo_name: jakubbrzeski/bullshit-paper


text:
---
hrs_structure:
  division: '1'
  volume: '3'
  title: '12'
  chapter: 195F
  section: 195F-5
type: hrs_section
tags:
  - Government
menu:
  hrs:
    identifier: HRS_0195F-0005
    parent: HRS0195F
    name: 195F-5 Forest stewardship management plans; approved activities
weight: 106025
title: Forest stewardship management plans; approved activities
full_title: 195F-5 Forest stewardship management plans; approved activities
---
**[§195F-5]** **Forest stewardship management plans; approved activities.** (a) To participate in the forest stewardship program, the applicant landowner shall prepare and submit to the board a forest stewardship management plan that shall:

(1) Identify and describe activities to be undertaken by the landowner to protect soil, water, aesthetic quality, recreation, timber, water, fish, wildlife, and native plant resources on the land in a manner that is compatible with the objectives of the program, is consistent with this chapter, and qualifies under the board's list of approved activities;

(2) Be signed by all parties having an interest in or holding any encumbrance upon the property, and shall state that the parties agree to comply with the plan upon its approval; and

(3) Be approved by the board and available for public review.

(b) The board and other cooperating natural resource management agencies shall develop a list of approved management activities and practices that shall be eligible for cost-share assistance under the program in the following areas:

(1) Enhanced management and maintenance of vegetation on vital watershed lands;

(2) Sustainable growth and management of forests for timber and other forest products on lands from which all or most of the native vegetation had been removed prior to January 1, 1991;

(3) Protection, restoration, and enhancement of native plants and animals;

(4) Management, maintenance, and restoration of forests for shelterbelts, windbreaks, aesthetic quality, and other conservation purposes on lands from which all or most of the native vegetation had been removed prior to January 1, 1991;

(5) Agroforestry management on lands from which all or most of the native vegetation had been removed prior to January 1, 1991;

(6) Management and maintenance of native fish and wildlife habitats;

(7) Management of outdoor recreational opportunities; and

(8) Other activities approved by the board, which are consistent with this chapter.

(c) The board shall encourage the use of private agencies, consultants, organizations, and firms to the extent feasible for the preparation of individual forest stewardship management plans and implementation of approved activities. [L 1991, c 327, pt of §2]

repository: SamMade/BlueAndKrabby

repo_name: SamMade/BlueAndKrabby


text:
# ReactFluxCart
This application is built with NodeJS, React, Flux, Gulp

With node installed, please install **gulp** globally:

`npm i -g gulp`

Install local dependecies

`npm install`

Now run `gulp` in the project folder. This builds the project in the `dist` folder and watches for any changes. We can serve via httpster is a great option for this (`npm i -g httpster`)

repository: krishnakc/ReactFluxCart

repo_name: krishnakc/ReactFluxCart


text:
# Instructions:

## Installing media server tools and pi-hole on linux mint / ubuntu

First, update system, and then install packages and deps.
This is for Deluge, Sonarr, Couchpotato, Tautulli. Plex runs on another server. Pi-hole runs in its own VM.

### Deluge

```
sudo apt update; sudo apt upgrade -y
sync
reboot
sudo apt install deluged deluge-console deluge-webui
sudo su -
nano
sudo nano /etc/passwd # change debian-deluged's shell to /bin/bash
sudo su debian-deluged -

# run as debian-deluged:
deluged
deluge-console
# in the console, it's like an irc client. enter this command:

config -s allow_remote true

# we will configure the rest later. enter this command:

quit

sudo nano /var/lib/deluged/.config/deluge/auth
# add username:password:10

# go back to root/sudoer user
exit

# (copy in the service files for deluged and sonarr - from this repo)
git clone https://github.com/melt7777/admintools
cp admintools/linux/mediaserver/*.service /etc/systemd/system
systemctl daemon-reload

sudo systemctl start deluged

sudo su debian-deluged -
# as debian-deluged user:

# load webui on 8112 to configure the server with (to turn on 58846)
deluge-web --fork

# point a brower at this box's ip:8112
# default pass is **deluge** , change it when it prompts you to
# connect it to your deluged server using connect button
# in preferences, click Daemon tab, click Allow Remote connections

```

### Sonarr
```
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 0xA236C58F409091A18ACA53CBEBFF6B99D9B78493
echo "deb http://apt.sonarr.tv/ master main" | sudo tee /etc/apt/sources.list.d/sonarr.list
sudo apt update
sudo apt install nzbdrone
sudo adduser sonarr
sudo su sonarr -
sudo systemctl enable sonarr.service
sudo systemctl start sonarr.service
# or manual run: screen -d -m -S sonarr mono --debug /opt/NzbDrone/NzbDrone.exe
```

### Tautulli (PlexPy)

Note: Plex Server is already installed and running on another host.
```
sudo addgroup tautulli && sudo adduser --system --no-create-home tautulli --ingroup tautulli
sudo apt-get install python python-setuptools tzdata
cd /opt
sudo git clone https://github.com/Tautulli/Tautulli.git
sudo mkdir /opt/Tautulli/mydata
sudo chown tautulli:tautulli -R /opt/Tautulli
cd Tautulli
# nano /etc/passwd and change tautulli's shell to /bin/bash
sudo su tautulli python Tautulli.py
# copy in the /etc/systemd/system/tautulli.service file
systemctl enable tautulli
systemctl start tautulli
```

### Pi-hole

`curl -sSL https://install.pi-hole.net | bash`

### Jackett

#### To install Jackett as a service

From instructions: https://github.com/Jackett/Jackett

```
# become root.

cd /opt

# Download and extract the latest Jackett.Binaries.LinuxAMDx64.tar.gz release from the releases page and run Jackett with the command `./jackett`

wget https://github.com/Jackett/Jackett/releases/download/v0.11.473/Jackett.Binaries.LinuxAMDx64.tar.gz
tar xvf Jackett.Binaries.LinuxAMDx64.tar.gz
cd Jackett
sudo ./install_service_systemd.sh

You need root permissions to install the service. The service will start on each logon. You can always stop it by running `systemctl stop jackett.service` from Terminal. You can start it again it using `systemctl start jackett.service`. Logs are stored as usual under ~/.config/Jackett/log.txt and also in `journalctl -u jackett.service`.
```

#### Adding a Jackett indexer in Sonarr or Radarr

- Go to Settings > Indexers > Add > Torznab > Custom.
- Click on the indexers corresponding  button and paste it into the Sonarr/Radarr URL field.
- For the API key use (redacted).
- Configure the correct category IDs via the (Anime) Categories options. See the Jackett indexer configuration for a list of supported categories.
- Adding a Jackett indexer in CouchPotato
- Go to Settings > Searchers.
- Enable TorrentPotato.
- Click on the indexers corresponding  button and paste it into the CouchPotato host field.
- For the Passkey use (redacted). Leave the username field blank.

#### Jackett auto-update

otherwise it just dies every few days.

Add to crontab:

```
0 1 * * * root /root/upjackett.sh
```

/root/upjackett.sh:

```bash
#!/bin/bash
# update Jackett.

cd /opt
rm -rf Jackett.old
mv Jackett Jackett.old
curl -s https://api.github.com/repos/Jackett/Jackett/releases/latest \
| grep "Jackett.Binaries.LinuxAMDx64.tar.gz" \
| cut -d : -f 2,3 \
| tr -d \" \
| wget -qi -
tar xvf Jackett.Binaries.LinuxAMDx64.tar.gz
chown -R sonarr:sonarr Jackett
systemctl start jackett
systemctl restart sonarr
```

#### Couch Potato

installation guide: https://vitux.com/how-to-install-couchpotato-on-ubuntu/

```
# become root
cd /opt
mkdir couchpotato
cd couchpotato/
git clone https://github.com/RuudBurger/CouchPotatoServer.git
cd CouchPotatoServer/
mv * ..
cd ..
rm -r CouchPotatoServer/
cp init/ubuntu /etc/init.d/couchpotato
chmod +x /etc/init.d/couchpotato
nano /etc/default/couchpotato

# paste in:
 CP_USER=sonarr
 CP_HOME=/opt/couchpotato
 CP_DATA=/home/sonarr/couchpotato

update-rc.d couchpotato defaults
service couchpotato start
```

#### Lidarr

install mono by guide https://www.mono-project.com/download/stable/#download-lin

```
sudo apt install gnupg ca-certificates
sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys 3FA7E0328081BFF6A14DA29AA6A19B38D3D831EF
echo "deb https://download.mono-project.com/repo/ubuntu stable-bionic main" | sudo tee /etc/apt/sources.list.d/mono-official-stable.list
sudo apt update
sudo apt install mono-devel
```

install lidarr by guide https://github.com/lidarr/Lidarr/wiki/Installation

```
cd /opt
wget https://github.com/lidarr/Lidarr/releases/download/v<IP_ADDRESS>3/Lidarr.develop.<IP_ADDRESS>3.linux.tar.gz
sudo tar -xzvf Lidarr.develop.<IP_ADDRESS>3.linux.tar.gz
useradd -s /bin/false -d /var/lib/lidarr/ -r -m -U lidarr
chown -R lidarr:lidarr   /opt/Lidarr
chmod -R a=,a+X,u+rw,g+r /opt/Lidarr
```

Create the file /etc/systemd/system/lidarr.service with the content:

```
[Unit]
Description=Lidarr Daemon
After=network.target

[Service]
User=lidarr
Group=lidarr
Type=simple
ExecStart=/usr/bin/mono /opt/Lidarr/Lidarr.exe -nobrowser
TimeoutStopSec=20
KillMode=process
Restart=on-failure
[Install]
WantedBy=multi-user.target
```

enable the service and start.
```
systemctl enable lidarr.service
systemctl start lidarr.service
systemctl status lidarr.service
```

Lidarr should be available on port 8686

#### Accessing these apps

the above installation using default ports would result in the following.

In the example, the host is <IP_ADDRESS>. Yours will be different.

- deluged on 58846
- jackett http://<IP_ADDRESS>:9117/UI/Dashboard
- tautulli http://<IP_ADDRESS>:8181/home#
- cpotato http://<IP_ADDRESS>:5050/
- sonarr http://<IP_ADDRESS>:8989


text:
# Installing the package

> * Level: Beginner
>
> * Reading Time: 10 minutes
>
> * Checked with: Unity Editor 2017.4 +, 2018.1 +,  2019.1 +, 2020.1 +

## Introduction

This package includes the support for Unity UI. You can use unlimited amount of pointers and canvases (note this will impact the performance).
This package is nothing more than a port of the original VRTK 3.3.0 UI System with some of the additional tweaks and fixes.
This system allows you to hover, select, drag, snap, click on all Unity UI component (except Toggle component).

If you have any issues with installation or usage, please make open an issue or go to the official VRTK4 discord.
Please, note if you need pointer to interact with other Non UI objects - please refer to Tilia.Interactions Interactables package (it is in there)

Also this package is fully compatible with VRTK 3.3.0 ,as all of the classes are renamed and stripped out of any legacy dependencies.

## Let's Start

### Installation (Pre-requisites)

1. Install Zinnia.Unity
2. Install Tilia.Interactions Interactables
3. Install Tilia.Indicators ObjectPointers
4. Install Tilia.UnityUI

You are ready to go!

### Usage : Part 1 VRTK Canvases

1. Add one or many World Canvas (this package will not work with any other type of canvases)
2. Add VRTK4_UICanvas component onto the Canvas to make it work with the system
3. Make sure you have only 1 active EventSystem at the start of the scene (package will add custom Input module to make sure Unity will recognize any pointer as valid UI  raycaster)
4. Add Unity UI standard Graphic Raycaster to enable casting on canvas.
5. Optionally set custom preferences for VRTK4_UICanvas (e.g. point with Interactor collider to make a click)

Note: Please spare as many canvases as you can, as the package package casts against all active VRTK4_UICanvas with active Graphic Raycaster enabled. The more active canvases you have the more raycasting will occur.

### Usage : Part 2 VRTK UI Pointer

1. Setup Interactor with appropriate input actions (Tilia.Interactions Interactables)
2. Add ObjectPointer.Straight (Tilia.Indicators ObjectPointers)
3. Navigate to PointsRenderer under ObjectPointer.Straight -> ObjectPointer.Internal -> Logic -> PointsHandler -> PointsRenderer
4. Add under PointsRenderer UI pointer prefab ( [L_R]_PointsRenderer UI Pointer.prefab )
5. Setup selection (enabling hover) and activation (press to click) input actions
6. Add VRTK4_Player Object component to your Interactor. Set which of the Pointers will it use as the target
7. Optionally set the Custom Origin (use it so that the pointer will not be inside the player collider)

### Done


text:
# DJL - MXNet native library

## Publishing MXNet native library

### Step 1: Prepare MXNet native library

Extract MXNet native library files from MXNet python pip wheel or build them from source.
Make sure collect all dependencies. Use the following commands include all the libmxnet.so dependencies:
```bash
# osx
otool -L libmxnet.dylib

# ubuntu
ldd libmxnet.so

# Windows
dumpbin /dependents libmxnet.dll
```

The example dependencies list for macOS mkl is:
- libmxnet.dylib (Be sure to rename libmxnet.so to libmxnet.dylib for macOS)

The example dependencies list for Windows mkl is:
- libmxnet.dll
- libopenblas.dll
- libgfortran-3.dll
- libquadmath-0.dll
- libgcc_s_seh-1.dll

The example dependencies list for Linux mkl is:
- libquadmath.so.0
- libgfortran.so.3
- libmxnet.so

### Step 2: Upload files to s3 bucket

The example list for s3 files is:
- s3://djl-ai/publish/mxnet-1.6.0/linux/common/libgfortran.so.3
- s3://djl-ai/publish/mxnet-1.6.0/linux/common/libquadmath.so.0
- s3://djl-ai/publish/mxnet-1.6.0/linux/cu101mkl/libmxnet.so
- s3://djl-ai/publish/mxnet-1.6.0/linux/cu92mkl/libmxnet.so
- s3://djl-ai/publish/mxnet-1.6.0/linux/mkl/libmxnet.so
- s3://djl-ai/publish/mxnet-1.6.0/osx/mkl/libmxnet.dylib
- s3://djl-ai/publish/mxnet-1.6.0/win/common/libgcc_s_seh-1.dll
- s3://djl-ai/publish/mxnet-1.6.0/win/common/libgfortran-3.dll
- s3://djl-ai/publish/mxnet-1.6.0/win/common/libopenblas.dll
- s3://djl-ai/publish/mxnet-1.6.0/win/common/libquadmath-0.dll
- s3://djl-ai/publish/mxnet-1.6.0/win/cu101mkl/libmxnet.dll
- s3://djl-ai/publish/mxnet-1.6.0/win/cu92mkl/libmxnet.dll
- s3://djl-ai/publish/mxnet-1.6.0/win/mkl/libmxnet.dll

### Step 3: Test publishing

Run the following commands to prepare your package:

```bash
cd mxnet/native

# Download native files and put into right folder
./gradlew dMNL

# Publish to build/repo folder
./gradlew publish

# Publish to sonatype snapshot repo
./gradlew publish -Psnapshot
```

### Step 4: Use GitHub action to publish MXNet native library

We have weekly GitHub pipeline to publish snapshot automatically. We can also use GitHub REST API to manually trigger a publish:

```bash
# manually trigger publish a snapshot release
curl -XPOST -u "USERNAME:PERSONAL_TOKEN" -H "Accept: application/vnd.github.everest-preview+json" -H "Content-Type: application/json" https://api.github.com/repos/USERNAME/RESPOSITORY_NAME/dispatches --data '{"event_type": “mxnet-snapshot-pub"}'

# trigger publishing MXNet to sonatype stagging
curl -XPOST -u "USERNAME:PERSONAL_TOKEN" -H "Accept: application/vnd.github.everest-preview+json" -H "Content-Type: application/json" https://api.github.com/repos/USERNAME/RESPOSITORY_NAME/dispatches --data '{"event_type": “mxnet-staging-pub"}'
```

repository: chenkelmann/djl

repo_name: chenkelmann/djl


text:
# README #

This README would normally document whatever steps are necessary to get your application up and running.

### What is this repository for? ###

* RBAC - Web Application
* (Rule Based Access Control)
* Version 1.0
* Author: 	Pudyasto Adi
* Website 1: 	http://www.pudyastoadi.my.id/
* Website 2:  http://pudyastoadi.dev.php.or.id
* Contact<EMAIL_ADDRESS>* Follow: 	https://twitter.com/pudyastoadi
* Like: 	https://www.facebook.com/dhyaz.cs
* License: 	http://opensource.org/licenses/MIT	MIT License

### How do I get set up? ###

* Install database
* Copy all *.copy.php into general files *.php
   - config/config.copy.php
   - config/database.copy.php
   - config/ion_auth.copy.php
   - libraries/Apps.copy.php
* Customize your setting
   - config/config.php
   - config/database.php
   - config/ion_auth.php
   - libraries/Apps.php

* Try your application

* Username And Password
    - After import database file, please use this username and password :
    - Username : administrator
    - Password : password

### Features ###
* This Application support MySQL Database, PostgresSQL Database

### Contribution guidelines ###

* AdminLTE - https://almsaeedstudio.com/themes/AdminLTE/index2.html
* Codeigniter 3 - https://codeigniter.com/
* HMVC - https://bitbucket.org/wiredesignz/codeigniter-modular-extensions-hmvc
* Template Engine - https://github.com/philsturgeon/codeigniter-template
* Ion Auth - https://github.com/benedmunds/CodeIgniter-Ion-Auth

### Who do I talk to? ###

*<EMAIL_ADDRESS>

### IMPORTANT ###
MIT License

Copyright (c) 2017 Pudyasto Adi W.

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

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

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

Happy coding!

repository: gilasgelas/rbac

repo_name: gilasgelas/rbac


text:
# DeLorean
**A Swift testing framework for code using NSDate**

[![Carthage compatible](https://img.shields.io/badge/Carthage-compatible-4BC51D.svg?style=flat)](https://github.com/Carthage/Carthage)

DeLorean is a µframework that allows you to exercise production code that depends on NSDate.  DeLorean allows you to explicitly specify the current time when running tests, so your tests don't pass if you run them at Noon but fail if you run them at 6.

## Usage

Using DeLorean is really quite simple.  DeLorean provides 3 public methods for manipulating dates.

```swift
public class func travelTo(date: NSDate?)

public class func travelTo(year: Int, month: Int, day: Int, hour: Int, minute: Int, second: Int) -> NSDate?

public class func backToThePresent()
```

All these methods are pretty self explanatory but lets go into further detail about how to use them.

First off I tend to call backToThePresent() in the tearDown or afterEach function of my test.  That looks something like this

```swift
override func tearDown() {
		DeLorean.backToThePresent()

		super.tearDown()
}
```

This just makes sure that every test starts fresh and we don't spill any changes we made in previous tests into other tests.

Then when I want to test my code given a specific time I can use the travelTo functions.
For example say I wanted to test that something happened on the first of the January.

```swift
func testSomethingHappensOnTheFirstOfJanuary() {
	DeLorean.travelTo(month: 1, day: 1)
	// Something Happens
}
```

All code executed after ```DeLorean.travelTo(month: 1, day: 1)``` NSDate.date() (which you're probably using everywhere) will return a Date in January on the 1st of the month.

If say you already have a date, like your users birthday and want to validate that something happens then you can use the other travelTo function.

```swift
func testWeWishOurUsersHappyBirthday() {
	DeLorean.travelTo(date: user.birthday)
	// some code that validates that we wished them a happy birthday
}
```

DeLorean also provides an optional parameter to the `travelTo` method, that will only adjust the date in a given block.  Implementing it looks something like this.

```swift
func testWeWishOurUsersHappyBirthday() {
	DeLorean.travelTo(date: user.birthday) {
		// some code that validates that we wished them a happy birthday
		// All dates return in this closure will return user.birthday
	}
	// All dates returned outside of this closure will be the current date/time.
}
```

Using the optional closure parameter is useful for cases where you only need to adjust the date in a single test case and it doesn't make sense to travel `backToThePresent` in your `tearDown` method at the end of *every* test case.

DeLorean for now is intentionally simple and I actually removed some NSDate and Int extensions before publishing it.  Hopefully this simplicity serves you well and allows your code and tests to remain clear without mucking things up too much.

Because DeLorean is meant to be used as a Testing framework, the best place to see it in action is in the tests for DeLorean itself.  DeLorean's tests also use [Miles](https://github.com/MadeByHecho/miles) a wrapper around XCTest to make Unit Tests just a bit more readable.

## Installation
The following instructions were taken and repurposed from [Quick](https://github.com/Quick/Quick) because it is the best resource I've seen for integrating with a Test Target.  As such please note that instead of dragging in Quick and Nimble you'll be dragging in DeLorean.

## How to Install DeLorean using [Carthage](https://github.com/Carthage/Carthage)
As Test targets do not have the "Embedded Binaries" section, the frameworks must be added to the target's "Link Binary With Libraries" as well as a "Copy Files" build phase to copy them to the target's Frameworks destination.
 > As Carthage builds dynamic frameworks, you will need a valid code signing identity set up.

1. Add DeLorean to your **[Cartfile.private](https://github.com/Carthage/Carthage/blob/master/Documentation/Artifacts.md#cartfileprivate)**

    ```
    github "MadeByHecho/DeLorean"
    ```

2. Run `carthage update`
3. From your `Carthage/Build/[platform]/` directory, add DeLorean to your test target's **Link Binary With Libraries** build phase
    ![](http://i.imgur.com/pBkDDk5.png)

4. For your test target, create a new build phase of type **Copy Files**
    ![](http://i.imgur.com/jZATIjQ.png)

5. Set the **Destination** to **Frameworks**, then add the DeLorean framework
    ![](http://i.imgur.com/rpnyWGH.png)

This is not 'the one and only way' to use Carthage to manage dependencies, for further reference check out the [Carthage documentation](https://github.com/Carthage/Carthage/blob/master/README.md)

## Credits & Contact

DeLorean was originally inspired by the Objective-C framework named [TUDelorean](https://github.com/tuenti/TUDelorean), which in turn was inspired by the rubygem [delorean](https://github.com/bebanjo/delorean).

If you have any questions I'm [@ScottPetit](http://twitter.com/ScottPetit) on Twitter.

repository: MadeByHecho/DeLorean

repo_name: MadeByHecho/DeLorean


text:
# lemonsong.github.io
This is the repository of my personal website.

Landing page and gallery page were modified based on pages created by **David Miller**, Managing Parter at [Iron Summit Media Strategies](http://www.ironsummitmedia.com/).


text:
# SummonBot

SummonBot can summon slack bot only define your environment.
SummonBot is Wrapped gem `Slack::Notifier`

## Installation
Add this line to your application's Gemfile:

```ruby
gem 'summon_bot'
```

And then execute:
```bash
$ bundle
```

Or install it yourself as:
```bash
$ gem install summon_bot
```

## Usage

First, define your environment for example

.env
```
SUMMON_BOT_SLACK__NATTSUNN=https://hooks.slack.com/services/XXXXXXXX/XXXXXXXX/XXXXXXXX
```

```
SummonBot::Slack.nattsunn.speak('notification')
=> #<Net::HTTPOK 200 OK readbody=true>
```

And this:

![](https://gyazo.com/151508f7304326f65edfe4bd5b029097/raw)

If you want to use dummy notification class, write this your code.
`initializer/summon_bot.rb` instead.

```
SummonBot::Slack.instance_eval { @notifier_class = SummonBot::DummyNotifier }
```

## Test command.

```
RAILS_ENV=test bundle exec rspec
```

## License
The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

gha_language: Ruby