text:
# ImageSize 1.0.3 for Statamic

A plugin to get either the width or height of an image.

## Usage:

	{{ imagesize path="{hero_image}" type="width" divide="2" }}

As in the example above, the tag is "imagesize" and takes the following parameters:

### path="/my/image"

Supply the path to the image you want ImageSize to get the width or height for. You can use a variable from one of your fields or hard code if needed.

### type="width|height"

Tell ImageSize if you want the width or the height of the image.

### divide="2"

This is actually why I developed this add-on, but I'll get to that in a minute. Supply a number to divide the image size by.

### parse_path="yes"

This allows you to use a plugin as input in the path parameter. This was added so that you get get a dimension of the native Statamic transform plugin. Sometimes you want to set a height or width only and let the other dimension be dynamic, but you need to know what that final dimension is. It works something like this:

	{{ imagesize path="{transform src='/nature.jpg' width='100' quality='100'}" parse_path="yes" type="height" }}

Note that the transform tag is in single curly brackets. Because of the way Statamic parses things, it won't work in double curly brackets.

## Why Is This Needed?!?

This solved a specific problem for me in developing a responsive, retina screen ready site with Statamic. I want all my images to be double resolution for retina devices, and I want the image to display at a maximum of half the actual size if the image for that reason. But I also need for it to be responsive for mobile devices, or as the browser width changes.

My solution is to get the image width, divide it in half, and set that as the width in the image tag. Then using CSS, the image is set to a max-width of 100% (or a pixel value if the specific context calls for it). This allows the image to be whatever size the user uploads (hopefully within reason, or limited by an image transform), but never get over half the size of the image.

## Feedback

I am pretty new to PHP and add-on development in general. I'm an HTML/CSS kind of guy. But I'm having fun learning new sills. That said, if you see any issues with this add-on or have general feed back, please do let me know. I promise I won't be offended.

## License

Copyright 2014 TJ Draper.

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

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

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

repository: tjdraper/ImageSize

gha_language: PHP

repo_name: tjdraper/ImageSize


text:
# docker-cogaps
Coordinated Gene Activity in Pattern Sets (CoGAPS, https://github.com/FertigLab/CoGAPS) implements a Bayesian MCMC matrix factorization algorithm,
GAPS, and links it to gene set statistic methods to infer biological process activity. It can be used to perform sparse matrix
factorization on any data, and when this data represents biomolecules, to do gene set analysis.

This repository packages CoGAPS as a docker container and also provides a GenePattern module wrapper for running
CoGAPS   as a GenePattern module.

repository: genepattern/docker-cogaps

branch_name: refs/heads/master

extension: md

gha_language: R

license_type: permissive

repo_name: genepattern/docker-cogaps


text:
# bbmod_node_render
`script`
```gml
bbmod_node_render(model, node, materials, transform)
```

## Description
Submits a Node structure for rendering.

### Arguments
| Name | Type | Description |
| ---- | ---- | ----------- |
| model | `array` | The Model structure to which the Node belongs. |
| node | `array` | The Node structure. |
| materials | `array` | An array of Material structures, one for each material slot of the Model. |
| transform | `array/undefined` | An array of transformation matrices (for animated models) or `undefined`. |

license: MIT

repository: short-bread/BBMOD

gha_license_id: MIT

repo_name: short-bread/BBMOD


text:
psycopg-nestedtransactions
==========================

[![Build Status](https://travis-ci.org/asqui/psycopg-nestedtransactions.svg?branch=master)](https://travis-ci.org/asqui/psycopg-nestedtransactions)

Database transaction manager for psycopg2 database connections with seamless support for nested transactions.

Use it like this:

    with Transaction(cxn):
       # do stuff

    # Transaction is automatically committed if the block succeeds,
    # and rolled back if an exception is raised out of the block.

Transaction nesting is also supported:

    with Transaction(cxn):
        with Transaction(cxn):
            # do stuff

This is useful for code composability, for example, if the inner transaction
is actually contained within library code.

    updateWidget(cxn, ...):
        """Make atomic changes to a widget across three different tables"""
        with Transaction(cxn):
            cur = cxn.cursor()
            cur.execute(...)  # Update data in widget table
            cur.execute(...)  # Update data in widget_id table
            cur.execute(...)  # Update data in widget_market_data table
        # If any statement fails, all changes to this widget are rolled back

    with Transaction(cxn):
        updateWidget(cxn, ...)  # Update widget A
        updateWidget(cxn, ...)  # Update widget B
        # If any widget fails to update, changes to all widgets are rolled back

Each transaction acts upon the changes made within that context and dictates
whether those changes are committed or rolled back, with the outermost transaction
being the ultimate arbiter of whether the net changes are committed or rolled back.

    with Transaction(cxn):
        for widget in widgets:
            try:
                updateWidget(cxn, widget)
            except:
                # Handle the failure and continue processing other widgets
        # If something else raises here, all changes are rolled back; alternately,
        # if this block exits successfully, all changes are committed at this point (and not before).

Commit and Rollback
-------------------

You may choose to rollback a transaction unconditionally, for example if
you are running in dry-run mode:

    dry_run_mode = True
    with Transaction(cxn, force_discard=dry_run_mode) as txn:
        # Do stuff
    # Transaction is rolled back

You cannot explicitly commit the transaction without exiting the block.

    with Transaction(cxn) as txn:
        txn.commit()  # This does not work

Just exit the block without raising to commit. For example:

    with Transaction(cxn):
        try:
            # try something that may fail
        except:
            # Handle the failure
    # Transaction is committed

In addition to the `force_discard` mode, it is also possible to
conditionally rollback inside the block without having to raise:

    with Transaction(cxn) as txn:
        updates = updateWidgets()
        if tooManyUpdates(updates):
            txn.rollback()
            log.warn('Too many updates. Changes rolled-back!')

Note that calling `rollback()` ends your transaction scope immediately.
Any further updates executed after the call to `rollback()` will be
executed outside the scope of this transaction (even if they are still
within the context manager):

    with Transaction(cxn) as txn:
        txn.rollback()
        # Updates made here are equivalent to...
    # ...updates made here.

Composability with classic transaction management
-------------------------------------------------

When introducing the `Transaction` context manager to an existing code
base which uses classic transaction management techniques, the
`Transaction` must be introduced in the innermost levels of code first.

For example, this works as desired:

    updateWidget(cxn, ...):
        """Make atomic changes to a widget across three different tables"""
        with Transaction(cxn):
            cur = cxn.cursor()
            cur.execute(...)  # Update data in widget table
            cur.execute(...)  # Update data in widget_id table
            cur.execute(...)  # Update data in widget_market_data table

    cxn = connect()
    cxn.autocommit = False
    try:
        updateWidget(cxn, ...)  # Update widget A
        updateWidget(cxn, ...)  # Update widget B
    except:
        cxn.rollback()
        raise
    else:
        cxn.commit()
    finally:
        cxn.close()

Note that it is **not** possible to introduce the `Transaction` context
manager at the outermost levels, surrounding code that uses classic
transaction management techniques.

For example, this will not work:

    updateWidget(cxn, ...):
        """This method uses classic transaction management techniques."""
        cxn.autocommit = False
        cur = cxn.cursor()
        try:
            cur.execute(...)  # Update data in widget table
            cur.execute(...)  # Update data in widget_id table
            cur.execute(...)  # Update data in widget_market_data table
        except:
            cxn.rollback()
            raise
        else:
            cxn.commit()

    cxn = connect()
    with Transaction(cxn):
        updateWidget(cxn, ...)  # Update widget A
        updateWidget(cxn, ...)  # Update widget B

Note that in this example, the first call to `updateWidget()` will
result in an explicit call to `commit()` or `rollback()` on the
underlying connection. This will not interact correctly with the
containing `Transaction` context.

Where possible, the `commit()` and `rollback()` methods are patched to
raise an exception for the duration of the `Transaction` context, to
help trap errors such as this.

Reusability and Reentrancy
--------------------------
The `Transaction` context manager is reusable. For example, you can do
this:

    txn = Transaction(cxn)
    with txn:
        # do stuff
    with txn:
        # do more stuff

This seems pointless in such a simple example, but there are other cases
where reusability may be helpful.

The `Transaction` context manager is *not* reentrant. This is not
supported and will not work:

    txn = Transaction(cxn)
    with txn:
        # do stuff
        with txn:  # Don't do this; it will not work!
            pass

(If you have a use case for reentrancy, raise an issue and we can
implement support for it!)

Development
-----------

1.  Install Postgres (See www.postgresql.org)
1.  Create a Virtual Environment:

        $ python3 -m venv psycopg-nestedtransactions
        $ cd psycopg-nestedtransactions

1.  Make `initdb` available in your PATH.
    (The postgres `testing.postgresql` library needs `initdb` to be available in your PATH,
    otherwise you will get `RuntimeError: command not found: initdb` errors).

    The appropriate path will likely be:
    *   On MacOS: `/Library/PostgreSQL/10/bin`
    *   On Linux: `/usr/lib/postgresql/10/bin`
    *   On Windows: `C:/Program Files/PostgreSQL/10/bin`

    Your options include:
    *   Add it to your system PATH (as appropriate for your operating system)
    *   Add it to your your venv `activate` script, with something along these lines:

            # Add postgres to PATH
            PATH="/Library/PostgreSQL/10/bin:${PATH}"
            export PATH

    * Add a symlink to `initd` in `/usr/bin`:

          sudo ln -s /usr/lib/postgresql/9.6/bin/initdb /usr/bin/initdb

1.  Activate the virtual env and install dependencies

        $ source bin/activate
        $ cd /path/to/source/root
        $ pip install -U -e .[test]

1.  Run the tests. They should all pass.

        $ pytest

Contributors
------------

* Daniel Fortunov
* Nigel Gott
* Harry Percival
* Nicole Vavrova

repository: tockards/psycopg-nestedtransactions

repo_name: tockards/psycopg-nestedtransactions


text:
# puppet-ec2init

CloudInit substitute for EC2 bootstrapping using Puppet.

## Why..

### Not CloudInit?

CloudInit doesn't truly support CentOS, yet. It is cumbersome to backport EL6 and morese EL5. It is amazingly complex in places.

### Not Bash?

Bash is not able to, without a lot of manual scaffolding: access meta-data and user-data, aintain SELinux file context labels, and idempotently manage file content, users and services.

### Puppet!

Puppet has a framework for doing all of the above. We already need it pre-installed in our AMIs anyway. It's a darn sight easier to read and write. It's less likely to conflict with our subsequent Puppet runs.

## How

It is a standalone Puppet module and accompanying SysVinit script that is designed to be baked into an AMI and run on every boot. It should bootstrap an otherwise vanilla AMI for subsequent, more fully featured, Puppet runs.

### Default actions

The following actions are performed by default:

- Creates a non-privileged user called `ec2-user`.
- Copies the SSH public key to that user from EC2 meta-data.
- Creates a sudoers rule for that user.
- Disables SSH remote root and password based logins.
- Logs the host's SSH public key fingerprints.

The init script will then perform a background run of the agent against a real master.

### Additional actions

Additional actions can be triggered by passing JSON content in userdata.

The following actions can be performed:

- Set the instance's hostname and domainname.
- Register the hostname in DNS using Route 53.
- Configure `puppet.conf` agent values.

Based on the following JSON:

``` json
{
    "hostname": "foo.bar.example.com",
    "route53": {
        "aws_access_key_id": "XXXXXXXXXXXXXXXXXXXX",
        "aws_secret_access_key": "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
    },
    "puppet": {
        "server": "puppet.example.com",
        "environment": "bar"
    }
}
```

gha_language: Ruby


text:
---
layout: article
title: Peas and GNOME Shell
date: 2022-09-26
---

[libpeas] is GObject-based plugin engine, allowing applications to adopt a
modular architecture and support third-party plugins. This article is about how
libpeas could be used in GNOME Shell and why that's a bad idea.

[libpeas]: https://gitlab.gnome.org/GNOME/libpeas

## Table of Contents

1. [GNOME Shell Extensions](#gnome-shell-extensions)
  * [Example Extension](#example-extension)
2. [Peas](#peas)
  * [PeasPluginInfo](#peasplugininfo)
  * [PeasExtension](#peasextension)
  * [PeasEngine](#peasengine)
4. [Conclusion](#conclusion)
  * [Disadvantages](#disadvantages)
  * [Working Example](#working-example)

## GNOME Shell Extensions

Although it's a piece of history forgotten to most, extensions were originally
envisioned as a way for developers to quickly prototype interface changes and
get feedback without requiring a complete rebuild of GNOME Shell. A recent
example of this is Florian Müllner's [Quick Settings Extension][quicksettings],
which was made available to GNOME 42 users, before being merged for GNOME 43.

The simplest way to understand the scope of an extension is to think of it as a
patch that is applied when it is enabled, and reverted when it is disabled. Like
any other patch an extension may add, remove or modify code. Likewise, just how
patches need to be rebased on the target branch, extensions sometimes need to be
updated to work with a newer version of GNOME Shell.

[quicksettings]: https://gitlab.gnome.org/fmuellner/quick-settings-extension

### Example Extension

Extensions have two required files: `extension.js` serving as an entry point for
its functionality and `metadata.json` which describes it:

```json
{
    "uuid"<EMAIL_ADDRESS>    "name": "Panel Hider",
    "description": "An extension that hides the panel.",
    "shell-version": ["42"]
}
```

Below is an example `extension.js` that simply hides the top panel:

```js
const Main = imports.ui.main

function enable() {
    Main.panel.visible = false;
}

function disable() {
    Main.panel.visible = true;
}

function init() {
}
```

When GNOME Shell loads an extension, it first imports `extension.js` and
invokes the `init()` function. This is used for one-time initialization of
things like translations.

When an extension is enabled the `enable()` function is invoked, which is when
extensions start adding, removing or even modifying existing code. When it is
disabled the `disable()` function is invoked and the extension is expected to
revert anything it did in `enable()`.

## Peas

Every plugin system has its own nomenclature and definitions of terms like
"plugin" and "extension". In Peas a plugin is more like a module as it can
define multiple classes. Each class is either derived from an abstract type or
implements an interface, and that base type is the extension type.

For example, a module called `files` could have one class implementing
`Gio.ListModel` and another derived from `Gio.IOStream`. Once registered, each
of these classes can be instantiated as an extension with the `Peas.Engine` by
passing the the plugin info and the type (`Gio.ListModel` or `Gio.IOStream`).

### PeasPluginInfo

Each plugin is described by a `.plugin` file, which is available in-process as a
[`Peas.PluginInfo`][peas-plugininfo]. The file itself is a standard keyfile
containing information comparable to `metadata.json`:

```ini
[Plugin]
Module=example
Name=Example
Description=An example plugin
```

In a typical use case, an application will add a search path which is scanned by
libpeas. The application may then load any or all of the discovered plugins and
once loaded may create instances of a plugin's extensions.

[peas-plugininfo]: https://gjs-docs.gnome.org/peas10/peas.plugininfo

### PeasExtension

A [`Peas.Extension`][peas-extension] object is actually just a proxy for an
underlying class instance. Each type that a plugin implements is an extension it
provides. These types are often defined by the application, but a plugin may
register any type that is either a subclass of an abstract type or an
implementation of an interface.

Below is a basic implementation of the [`Peas.Activatable`][peas-activatable]
interface, derived from the [`Peas.ExtensionBase`][peas-extensionbase] class. It
is defined as dynamic type, so that the type may be registered and unregistered
without conflicts (i.e. updating the plugin without restarting the application).

`bean-activatable.h`
```c
#pragma once

#include <libpeas/peas.h>

G_BEGIN_DECLS

#define BEANS_TYPE_ACTIVATABLE (beans_activatable_get_type ())

G_DECLARE_FINAL_TYPE (BeansActivatable, beans_activatable, BEANS, ACTIVATABLE, PeasExtensionBase)

G_END_DECLS
```

`bean-activatable.c`
```c
#include <gio/gio.h>
#include <libpeas/peas.h>

#include "beans-activatable.h"

struct _BeansActivatable
{
  PeasExtensionBase  parent_instance;

  GObject           *object;
};

static void   peas_activatable_iface_init (PeasActivatableInterface *iface);

G_DEFINE_DYNAMIC_TYPE_EXTENDED (BeansActivatable, beans_activatable, PEAS_TYPE_EXTENSION_BASE,
                                0,
                                G_IMPLEMENT_INTERFACE_DYNAMIC (PEAS_TYPE_ACTIVATABLE, peas_activatable_iface_init))

enum {
  PROP_0,
  PROP_OBJECT
};

static void
beans_activatable_activate (PeasActivatable *activatable)
{
  g_message ("%s()", G_STRFUNC);
}

static void
beans_activatable_deactivate (PeasActivatable *activatable)
{
  g_message ("%s()", G_STRFUNC);
}

static void
beans_activatable_update_state (PeasActivatable *activatable)
{
  g_message ("%s()", G_STRFUNC);
}

static void
peas_activatable_iface_init (PeasActivatableInterface *iface)
{
  iface->activate = beans_activatable_activate;
  iface->deactivate = beans_activatable_deactivate;
  iface->update_state = beans_activatable_update_state;
}

static void
beans_activatable_get_property (GObject    *object,
                                guint       prop_id,
                                GValue     *value,
                                GParamSpec *pspec)
{
  BeansActivatable *self = BEANS_ACTIVATABLE (object);

  switch (prop_id)
    {
    case PROP_OBJECT:
      g_value_set_object (value, self->object);
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    }
}

static void
beans_activatable_set_property (GObject      *object,
                                guint         prop_id,
                                const GValue *value,
                                GParamSpec   *pspec)
{
  BeansActivatable *self = BEANS_ACTIVATABLE (object);

  switch (prop_id)
    {
    case PROP_OBJECT:
      self->object = g_value_get_object (value);
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    }
}

static void
beans_activatable_class_finalize (BeansActivatableClass *klass)
{
}

static void
beans_activatable_class_init (BeansActivatableClass *klass)
{
  GObjectClass *object_class = G_OBJECT_CLASS (klass);

  object_class->get_property = beans_activatable_get_property;
  object_class->set_property = beans_activatable_set_property;

  g_object_class_override_property (object_class, PROP_OBJECT, "object");
}

static void
beans_activatable_init (BeansActivatable *self)
{
}

/*
 * Registering the extension
 */
G_MODULE_EXPORT void
peas_register_types (PeasObjectModule *module)
{
  beans_activatable_register_type (G_TYPE_MODULE (module));

  peas_object_module_register_extension_type (module,
                                              PEAS_TYPE_ACTIVATABLE,
                                              BEANS_TYPE_ACTIVATABLE);
}
```

[peas-activatable]: https://gjs-docs.gnome.org/peas10/peas.activatable
[peas-extension]: https://gjs-docs.gnome.org/peas10/peas.extension
[peas-extensionbase]: https://gjs-docs.gnome.org/peas10/peas.extensionbase

### PeasEngine

The [`Peas.Engine`][peas-engine] is essentially a factory for extensions and is
used to scan for plugins, load and unload plugins, and create instances of
extensions. It is usually used as a singleton and sometimes only indirectly via
[`Peas.ExtensionSet`][peas-extensionset].

In the example below, we're assuming the example plugin has been compiled into
`libexample.so` and placed in `~/.local/share/beans/plugins` along with the
`example.plugin` file describing it.

```js
const { GLib, Peas } = imports.gi;

let engine = null;
let extension = null;

function enable() {
    // Loading each plugin in the search path
    for (const pluginInfo of engine.get_plugin_list()) {
        engine.load_plugin(pluginInfo);

    // Creating an instance of Beans.Activatable
    const pluginInfo = engine.get_plugin_info('example');

    extension = engine.create_extension(pluginInfo, Peas.Activatable,
        ['object'], [this]);

    // Calling a method on the extension
    extension.activate();
}

function disable() {
    extension.deactivate();
    extension = null;

    // Unloading each plugin in the engine
    for (let pluginInfo of engine.get_plugin_list())
        engine.unload_plugin(pluginInfo);
}

function init() {
    // Adding a search path to the engine
    const pluginsDir = GLib.build_filenamev([GLib.get_user_data_dir(),
        'beans', 'plugins']);

    engine = Peas.Engine.get_default();
    engine.prepend_search_path(pluginsDir, null);
}
```

[peas-engine]: https://gjs-docs.gnome.org/peas10/peas.engine
[peas-extensionset]: https://gjs-docs.gnome.org/peas10/peas.extensionset

## Conclusion

Using libpeas to provide a more traditional plugin system for GNOME Shell is
entirely possible, but it has hopefully been demonstrated that there isn't much
to gain by doing it. The fact that a GNOME Shell extension can be used to
implement a plugin system should speak to the power and flexibility of the
existing extension system.

### Disadvantages

In order to call methods on an extension or even create one, you must have
introspection data for that type (i.e. a GIR file to import in GJS). Unlike
JavaScript classes, or even GObject classes defined in GJS, you can't simply
create classes and call methods on them.

Although you could distribute an extension like the example above on the
[GNOME Extensions][ego] website, you can't distribute C plugins along with it.
Unlike GNOME Shell extensions, compiled plugins are architecture dependent,
depend on the linked ABI and extension review prohibits distributing binaries
regardless.

At the same time, it's not possible to use libpeas to import Python plugins in
GJS, because you can't use two garbage collected languages in the same GObject
program. Unfortunately writing plugins in GJS is not currently supported by
libpeas, but if it were you would gain nothing by doing so.

[ego]: https://extensions.gnome.org

### Working Example

[Beans][beans] is a working example of using libpeas in a GNOME Shell extension
to load plugins written in C. It supports a few extension types, with examples
of how they can be instantiated and used.

It also includes a `Clutter.Actor` extension by linking to a specific version of
[Mutter][mutter] and using one of the interfaces already implemented by
`Clutter.Actor` as the extension type.

[beans]: https://github.com/andyholmes/gnome-shell-extension-beans
[mutter]: https://gitlab.gnome.org/GNOME/mutter

license: Unlicense

branch_name: refs/heads/main

gha_language: CSS


text:
# Emboss entries on bio.tools

While using ToolDog to annotate existing wrappers from the main Galaxy, I encountered entries on
https://bio.tools where the EDAM terms did not have uri. This concerned tools linked to the
DOI `10.1016/S0168-9525(00)02024-2`.

Therefore, for every tools linked to this DOI, I checked the topics describing the entries and this
is available in emboss\_topics.tsv

repository: khillion/galaxyxml-analysis

repo_name: khillion/galaxyxml-analysis


text:
# New way to visualize your data

### Using Dash (built over Flask Python web-framework)
[Dash](https://plot.ly/products/dash/) is built with the help of the [React](https://reactjs.org/) structure internally, which made it work really fast, even made live-graphing possible.

### Insights and motivation
Twitter streaming data can be classified in real-time using various ML-techniques and updated right away inside the app using Dash as visualization tool

### Where is it running
It is currently deployed with free account on [Heroku](https://www.heroku.com/). Hosted on this funky webpage - [intelligent-maison](https://intelligent-maison-90061.herokuapp.com/)

### LICENSE
Apache License 2.0
2018
K Tejas Reddy


text:
# Phones

Phones is a barebones phone parsing and formatting library. If the phone is number is outside of the United States, it must include the country code prefixed with a "+"

It can parse phone numbers like:
-<PHONE_NUMBER>
-<PHONE_NUMBER>
-<PHONE_NUMBER>
-<PHONE_NUMBER>
-<PHONE_NUMBER>3
- 1-(925)-200-8843
- +49 69 6900
- +49696900
- +19252008843

And any combination between those.

## Installation

First, install it:
```bash
gem install phones
```

In your Gemfile:
```ruby
gem 'phones', :require => 'phones'
```

## Usage

It adds a ```to_phone``` method to ```String```, so you can just do:
```ruby
"1-(925)-200-8843".to_phone
=> +19252008843
```

Pretty printing phone numbers:
```ruby
"1-(925)-200-8843".to_phone.pretty
=> "(925) 200-8843"
```

Country code, area code, local code:
```ruby
phone = "1-(925)-200-8843".to_phone
=> +19252008843
phone.country_code
=> "+1"
phone.area_code
=> "925"
phone.local_code
=> "2008843"
```

Note: ```area_code``` and ```local_code``` is currently only supported for US phone numbers. International phone numbers will have a ```nil``` area_code and ```local_code``` will contain the rest of the phone number. ```country_code``` should work for every country code.

It'll return nil if it couldn't detect a valid phone number.

repository: lockitron/phones

repo_name: lockitron/phones


text:
# Language Structures Modding Guide

Procedurally generated languages in *Worlds* are built by "translating" English words and sentences defined in mod files like *elements.json*, *region_attributes.json* and sometimes within the game itself. In order for this to work, the input strings given in those documents must follow a format that instructs the word parser on how to understand each word or phrase. This document attempts to describe the structure and keywords used to facilitate the parsing process.

### NOUNS

Nouns are single words that are used to identify people, groups of people, locations or other types of objects within the game. These can be used in singular or plural form and be merged together with other nouns or adjectives. They can be built from  verbs or other type of words through processes like verb nominalization.

In most cases, nouns must be defined in 'plural' form. If done correctly, the parser will be able to recognize the singular part of the word. To do so, the noun definition must separate the plural suffix element, `s` or `es`, using a colon `:` like in the following examples:

  `stone:s`, `sun:s`, `moon:s`, `bush:es`, `box:es`, `potato:es`

For irregular nouns, the `in` annotation, encased within brackets, is prefixed. The annotation must include as a parameter the noun's singular spelling. Here are some examples:

  `[in(foot)]feet`, `[in(tooth)]teeth`, `[in(sky)]skies`, `[in(knife)]knives`, `[in(man)]men`, `[in(child)]children`

Certain collective nouns, like `people`, can also be assigned a singular spelling `[in(person)]people`. This should be rarely done as it can lead to translation ambiguities.

#### Agent Nouns

Agent nouns are nouns constructed from words (in this case specifically, verbs) denoting actions. Examples are `runner`, `builder`, `carrier`. *Worlds*' language generator can identify the verb part of agent nouns if properly annotated. In this way, the language builder can make both the verb and the noun derived from it share a root on generated languages. There are two ways to annotate agent nouns:
  - Regular agent nouns (nouns terminating with `er` or `r`) are prefixed within brackets with the annotation `ran` and separate the suffix element with `:`. Examples:

    `[ran]breath:er`, `[ran]throw:er`, `[ran]burn:er`, `[ran]dance:r`, `[ran]swim:mer`, `[ran]cut:ter`

  - Irregular agent nouns (slight noun spelling variation) are prefixed within brackets with the annotation 'ian' with the original verb spelling as a parameter. Examples:

    `[ian(carry)]carrier`, `[ian(translate)]translator`

#### Noun Adjuncts

Noun Adjuncts are single-word nouns that are associated with other nouns much in the same way as adjectives. These must be annotated with the keyword `nad`. Here are some examples:

  `[nad]ice cap`, `[nad]ice sheet`, `[nad]wood table`, `[nad]stone tower`

### VERBS

Though not fully implemented yet, the language generator can produce translations for a limited set of verbal conjugations to construct noun phrases.

To translate a regular verb, the conjugation must be prefixed with the `rv` annotation and two parameters, the grammatical person, and the grammatical tense. The suffix must be separated of the verb using `:`. Here are some examples:

  `[rv(ts,past)]scare:d`, `[rv(ts,past)]soak:ed`

To translate a irregular verb, the conjugation must be prefixed with the `iv` annotation and three parameters, the uninflected verb, the grammatical person, and the grammatical tense. Here are some examples:

  `[iv(bear,ts,past)]born`, `[iv(pin,ts,past)]pinned`, `[iv(cut,ts,past)]cut`

## Notes:
1. There are some cases of regular action nouns or verbs that can't be parsed using the annotations `ran` or `rv`. In those cases it is Ok to use the irregular form annotations `ian` or `iv` respectively.
2. The language generation process is still very limited. Please report any issues to the author (**drtardigrage -at- gmail.com**). Please provide examples of the particular issues found when reporting.

repository: Zematus/Worlds

gha_language: C#

repo_name: Zematus/Worlds


text:
# Database of employees

Database of employees in C (student project)

##Install Requirements

###Linux

`sudo apt-get install g++` - Install GCC Compiler
`sudo apt-get install cmake` - Install CMake

##Download

Clone git repository with terminal command
`https://github.com/markokosticdev/database-of-employees-c.git`

##Documentation

See the source code

repository: markokosticdev/database-of-employees-c

repo_name: markokosticdev/database-of-employees-c


text:
# astc-transcoder
Transcoder is a [CLI](https://en.wikipedia.org/wiki/Command-line_interface) tool for saving 2D images to [KTXv1](https://www.khronos.org/opengles/sdk/tools/KTX/file_format_spec/) media container for [ASTC](https://www.khronos.org/opengl/wiki/ASTC_Texture_Compression) format with mipmap autogenerating.

## Supported formats
- `dds`
- `png`
- `jpg`
- `tga`
- `bmp`

## Deployment
Tutorial video is [here](https://drive.google.com/file/d/13Yli_vlsDumqeN2v-G_JgP3BvFET9agr/view?usp=sharing).

## How to use
Please refer to the [documentation](./documentation/manual.md).

## Quick start instructions
Requirements:

* _Windows Vista_+
* _Visual Studio 2019 v16.7.6_
* _Windows SDK v10.0.18362.0_
* [_AMD Compressonator_](https://github.com/GPUOpen-Tools/compressonator) _v4.0.4855.0_

Optional:
* [_InnoSetup_](https://jrsoftware.org/isdl.php) _v6.0.5 (u)_

To begin, clone this repository onto your local drive.

Next step is to compile project via _Visual Studio_ as usual.

repository: Goshido/astc-transcoder

repo_name: Goshido/astc-transcoder


text:
# SPReports

Download compiled version of tools under [Releases](https://github.com/ronnieholm/Bugfree.SharePoint.DiagnosticTools/releases).

Generates custom reports based on metadata in SharePoint by first
collecting and dumping relevant metadata to a file and then quering it
offline. SPReports comes with a few pre-defined reports, but using any
.NET language, new reports can be crafted from the metadata dump.

```
USAGE: SPReports.exe [--help] [<subcommand> [<options>]]

SUBCOMMANDS:

    --dump-metadata <options>
                          dump metadata.
    --webs-file-extensions-count <options>
                          analyze dump and summarize files by extension and count.
    --webs-add-ins <options>
                          analyze dump and create webs by add-ins table.
    --webs-workflows <options>
                          analyze dump and create webs by workflow instances table.

    Use 'SPReports.exe <subcommand> --help' for additional information.

OPTIONS:

    --help                display this list of options.
```

## --dump-metadata

Dumps metadata from across site collections, webs, lists, and
workflows for later consumption by reporting commands. Instead of
combining collection and dumping, which carries a heavy runtime cost,
with reporting, the latter is kept separate for speed and
reproducability.

Example:

    .\SPReports.exe --dump-metadata --username<EMAIL_ADDRESS>--password secret --tenant-name bugfree --ouptput-path .\dump.bin

Collects metadata using the username and password provided. All site
collections, webs, lists, and workflows within the bugfree tenant are
traversed, and output is written to a binary file named dump.bin.

The user provided must be a tenant administrator.

## --webs-file-extensions-count

Generates a CSV report of webs by file extension count in the form of
a CSV file. This is useful for getting an idea of which types of files
users are storing. Perhaps files with some extensions shouldn't go
into SharePoint but another application, e.g., CAD drawings or GIS
data.

Example:

    .\SPReports.exe --webs-file-extensions-count --input-path .\dump.bin --output-path .\dump.csv

Outputs a CSV file containing a matrix enumerating webs and file
extensions extracted from the dump file. The value of the (web,
extension) element in the matrix is the number of files within the web
with that extension.

## --webs-add-ins

Generates a CSV report containing apps installes on all webs. For
Nintex Workflow and Nintex Forms in particular, the report also
includes their version numbers. For instance, this enables upgrading
the Nintex Workflow and Forms app to a version supported when moving
from one Nintex datacenter to another.

Example:

    .\SPReports.exe --webs-add-ins --input-path .\dump.bin --output-path .\dump.csv

## --webs-workflows

Generates a CSV report containing workflow instances across all webs
with a column descriminating SharePoint's build-in workflow instances
from Nintex instances.

Example:

    .\SPReports.exe --webs-workflows --input-path .\dump.bin --output-path .\dump.csv

## Supported platforms

SharePoint 2013 and SharePoint Online.


text:
jsruntime
=========

This is a [Google Chrome extension](https://chrome.google.com/webstore/detail/js-runtime-inspector/iilpjebedgohcmlffhnkhbjhabkdhfmn ) to explore javascript runtime.

It allows developers to explore javascript objects graph in memory. You can search objects by property names or values.

Be careful though - it uses regex to find properties. You can easily hang your browser if your object model is large.

[See video](http://www.youtube.com/watch?v=x91YVWQsw2g) of it in action.

repository: majicmike/jsruntime

repo_name: majicmike/jsruntime


text:
# :hourglass: Past Events

These are CSS Frankfurt's past events. You can find links to resources from the events here as well.

## CSS Variables: Custom Properties

Welcome back to another event! 😻 We are proud to announce that Lennart (@lekoarts_de) will be giving a talk about CSS variables, or as he prefers to call them: Custom Properties!

**When?** Thursday, September 13 @ 18:30

**Where?** [Die Zentrale Coworking](locations.md#die-zentrale-coworking)

[Learn more...](https://www.meetup.com/CSSFrankfurt/events/253010928/)

**Resources**

- [GitHub repo](https://github.com/LeKoArts/css-custom-properties-examples) - The repository contains the slides for the talk as well
- [Practical examples](https://css-variables.netlify.com) - A website with the practical examples from the talk

## CSS-in-JS: The Future of Component-Based Styling

As the web is moving towards a component based approach, many agree that the limitations of CSS require us to change how we write our styles. CSS-in-JS is one possible solution that enables us to write styles in declarative, maintainable JavaScript.

**When?** Thursday, August 23 @ 18:30

**Where?** [Die Zentrale Coworking](locations.md#die-zentrale-coworking)

[Learn more...](https://www.meetup.com/CSSFrankfurt/events/253010920/)

**Resources**

- [GitHub repo](https://github.com/flxwu/css-in-js)
- [Slides](https://slides.com/flxwu/css-in-js/)

## Let there be burgers

Let's catch up and get to know each other better over burgers! :hamburger::heart_eyes_cat: Meet us at Luna Burger in the city (near Konstablerwache, see map) to fill up on yummy food and drinks with new friends!

**When?** Thursday, June 28 @ 19:00

**Where?** [Luna Burger](locations.md#luna-burger)

[Learn more...](https://www.meetup.com/CSSFrankfurt/events/251749195/)

## Coding Night: CSS Grid 2.0

It’s time for another Frank’s Coding Night! :cat_heart_eyes: The first Coding Night was a great success and we hope to see you again for more social coding!

**When?** Thursday, May 24 @ 18:00

**Where?** [Die Zentrale Coworking](locations.md#die-zentrale-coworking)

[Learn more...](https://www.meetup.com/CSSFrankfurt/events/250654063/)

## Coding Night: CSS Grid

Frank is inviting you back to Die Zentrale for a social coding event! There will be two topics covered at this event, CSS images and CSS grid. For the CSS images part, you will be able to recreate one of Victoria’s CSS images (we will choose one together). This is a great exercise to improve your overall CSS skills, for example increase efficiency, becoming better at positioning and learning new properties.

**When?** Friday, April 27 @ 19:00

**Where?** [Die Zentrale Coworking](locations.md#die-zentrale-coworking)

[Learn more...](https://www.meetup.com/CSSFrankfurt/events/249591142/)

## Kickoff Party

We are happy to announce that our first event is happening on March 22 at Die Zentrale Coworking Space in Bornheim Mitte. This event will be dedicated to getting to know our members and what CSS Frankfurt can do for you and the community.

**When?** Thursday, March 22 @ 19:00

**Where?** [Die Zentrale Coworking](locations.md#die-zentrale-coworking)

[Learn more...](https://www.meetup.com/CSSFrankfurt/events/248339933/)


text:
# Contributing Guidelines

## How to start

1. Create a pull request on master
2. Make sure the github action that automatically checks your proofs passes.
3. Wait for at least one approval from a reviewer
4. Merge (or poke for a merge, depending on your permissions)
5. Add yourself to the AUTHORS file

## FAQ

### Where to jump in

1. Find a TODO or Admitted or Abort proof and try to prove it.
2. Read the paper and find something we haven't proved yet.
3. Open an github issue, if you would like to prove something different that you still feels belong here.

### I have an alternative proof

The more the merrier.

We welcome alternative proofs.  Please submit your proof with a new name, by adding a tick `'` at the end of the function name.

Reason: This is a learning repo and seeing alternatives to the same proof is helpful.  This is not just helpful in pull requests, but also to new comers to the repo and that is why it is still useful to merge them into master.

### Comments

 - Do we like comments? Yes we do.
 - Are they required? No.

### When to use a separate file

Now.  When you are starting to ask this question, it is time to start using a separate file. Please make sure to add it to the Makefile, so that the proofs are checked in the pull request.

### TODO, Admitted and Abort

Yes we can merge an Admitted or Abort proof with a TODO comment.  This is where reviewing the code is important.  We need to believe that the Admitted proof is provable by us in future and we prefer an Abort proof as a way of documenting an interesting theorem to prove, but we understand that sometimes an Admitted proof is needed.

A proof may be left out if:

 - you are lazy, for example maybe you see the proof will be similar to other proofs (this gives beginners an opportunity to also contribute).  In this case please add `(* TODO: Good First Issue *)`
 - you need help (this gives beginners who are up for a challenge, a chance to contribute). In this case please add `(* TODO: Help Wanted *)`

### Tactics

Tactics unlike proofs, definitions, etc. don't have any types.
This means they lack some documentation and type checking.
For this reason, we prefer that new tactics come with:
  - some comments above that describe the tactic.
  - some examples below that use the tactic.

If you see a tactic that doesn't meet these requirements at the moment, consider it a Good First Issue.

### Examples

Examples are especially useful for checking that our tactics are working as predicted.

Examples should use the `Example` keyword and the name should be prefixed with `example_`.

```
Example example_<my example name>:
```

repository: maribouwer/regex-reexamined-coq

repo_name: maribouwer/regex-reexamined-coq


text:
# gatsby-source-graphql

Plugin for connecting arbitrary GraphQL APIs to Gatsby GraphQL. Remote schemas are stitched together by adding a type that wraps the remote schema Query type and putting it under field of Gatsby GraphQL Query.

- [Example website]([See it here](https://using-gatsby-source-graphql.netlify.com/))
- [Example website source]([See it here](https://github.com/gatsbyjs/gatsby/tree/master/examples/using-gatsby-source-graphql))

## Install

`npm install --save gatsby-source-graphql`

## How to use

```javascript
// In your gatsby-config.js
module.exports = {
  plugins: [
    // Simple config, passing URL
    {
      resolve: "gatsby-source-graphql",
      options: {
        // This type will contain remote schema Query type
        typeName: "SWAPI",
        // This is field under which it's accessible
        fieldName: "swapi",
        // Url to query from
        url: "https://api.graphcms.com/simple/v1/swapi",
      },
    },
    // Passing paramaters (passed to apollo-link)
    {
      resolve: "gatsby-source-graphql",
      options: {
        typeName: "GitHub",
        fieldName: "github",
        // Url to query from
        url: "https://api.github.com/graphql",
        // HTTP headers
        headers: {
          Authorization: "bearer <GITHUB_TOKEN>",
        },
        // Additional options to pass to node-fetch
        fetchOptions: {},
      },
    },
    // Creating arbitrary Apollo Link (for advanced situations)
    {
      resolve: "gatsby-source-graphql",
      options: {
        typeName: "GitHub",
        fieldName: "github",
        // Create Apollo Link manually. Can return a Promise.
        createLink: (pluginOptions) => {
          return createHttpLink({
            uri: 'https://api.github.com/graphql',
            headers: {
              'Authorization': `bearer ${process.env.GITHUB_TOKEN}`,
            },
            fetch,
          })
      },
    },
  ],
}
```

## How to Query

```graphql
{
  # Field name parameter defines how you can access third party api
  swapi {
    allSpecies {
      name
    }
  }
  github {
    viewer {
      email
    }
  }
}
```

## Schema definitions

By default schema is introspected from the remote schema. Schema is cached in `.cache` in this case and refreshing the schema requires deleting the cache.

To control schema consumption, you can alternatively construct schema definition by passing `createSchema` callback. This way you could, for example, read schema SDL or introspection JSON. When `createSchema` callback is used, schema isn't cached. `createSchema` can return a Promise to GraphQLSchema instance or GraphQLSchema instance.

```js
const fs = require("fs")
const { buildSchema, buildClientSchema } = require("graphql")

module.exports = {
  plugins: [
    {
      resolve: "gatsby-source-graphql",
      options: {
        typeName: "SWAPI",
        fieldName: "swapi",
        url: "https://api.graphcms.com/simple/v1/swapi",

        createSchema: async () => {
          const json = JSON.parse(
            fs.readFileSync(`${__dirname}/introspection.json`)
          )
          return buildClientSchema(json.data)
        },
      },
    },
    {
      resolve: "gatsby-source-graphql",
      options: {
        typeName: "SWAPI",
        fieldName: "swapi",
        url: "https://api.graphcms.com/simple/v1/swapi",

        createSchema: async () => {
          const sdl = fs.readFileSync(`${__dirname}/schema.sdl`).toString()
          return buildSchema(sdl)
        },
      },
    },
  ],
}
```

# Refetching data

By default, `gatsby-source-graphql` will only refetch the data once the server is restarted. It's also possible to configure the plugin to periodically refetch the data. The option is called `refetchInterval` and specifies the timeout in seconds.

```js
module.exports = {
  plugins: [
    // Simple config, passing URL
    {
      resolve: "gatsby-source-graphql",
      options: {
        // This type will contain remote schema Query type
        typeName: "SWAPI",
        // This is field under which it's accessible
        fieldName: "swapi",
        // Url to query from
        url: "https://api.graphcms.com/simple/v1/swapi",

        // refetch interval in seconds
        refetchInterval: 60,
      },
    },
  ],
}
```


text:
# Dumpling Bot ![Python3.5](https://camo.githubusercontent.com/53aa0b9151bc545b404852175644228ee0efffe2/68747470733a2f2f696d672e736869656c64732e696f2f62616467652f707974686f6e2d332e352d626c75652e737667) ![Build Passing](https://camo.githubusercontent.com/7795340899e8ed519dc205d2c73b2360e17faaba/68747470733a2f2f7472617669732d63692e6f72672f626f656e6e656d616e6e2f6261646765732e7376673f6272616e63683d6d6173746572)

*A WeChat bot.*

Latest Version: **Pre-Release (Alpha 1.2.0)**

Python Version: **3.5**

Supported OS: **OSX(macOS)** / Windows (unsure)

Dependencies: **itchat**, **requests (modified)**, bs4, sympy, pydub

## Known Issues
See [Issues](https://github.com/yu-george/Dumpling-Bot/issues)

## Goals
- [x] News
- [x] Jokes
- [ ] Movie downloads
- [ ] Buy movie tickets
- [ ] Better chat system
- [ ] Account upgrading

repository: georgeyjm/Dumpling-Bot

repo_name: georgeyjm/Dumpling-Bot


text:
# Get The Job Details

API of Getinng Training Job Details can get the training job details.

## Path

pkg/apis/arenaclient.TrainingJobClient

## Function

	func (t *TrainingJobClient) Get(jobName string, jobType types.TrainingJobType) (*types.TrainingJobInfo, error)

## Parameters

* jobName(type: string) => the name of training job
* jobType(type: pkg/apis/types.TrainingJobType) = > specify the training job type

## Example

### Get the training job details(training job type is unknown)

	package main
	import(
		"fmt"
		"github.com/kubeflow/arena/pkg/apis/arenaclient"
		"github.com/kubeflow/arena/pkg/apis/types"
	)

	func main() {
		// create the arena client
		client, err := arenaclient.NewArenaClient(types.ArenaClientArgs{
			Kubeconfig:     "",
			LogLevel:      	"debug",
			Namespace:      "",
			ArenaNamespace: "",
			IsDaemonMode:   false,
		})
		if err != nil {
			fmt.Printf("failed to build arena client.,reason: %v",err)
			return
		}
		// get the training job which name is test and its' type is unknown
		trainingJob,err := client.Training().Get("test",types.AllTrainingJob)
        if err != nil {
            fmt.Printf("failed to get training job,reason: %v",err)
            return
        }
        fmt.Printf("training job status: %v\n",trainingJob.Status)
	}

### Get the training job details(training job type is known)

	package main
	import(
		"fmt"
		"github.com/kubeflow/arena/pkg/apis/arenaclient"
		"github.com/kubeflow/arena/pkg/apis/types"
	)

	func main() {
		// create the arena client
		client, err := arenaclient.NewArenaClient(types.ArenaClientArgs{
			Kubeconfig:     "",
			LogLevel:      	"debug",
			Namespace:      "",
			ArenaNamespace: "",
			IsDaemonMode:   false,
		})
		if err != nil {
			fmt.Printf("failed to build arena client.,reason: %v",err)
			return
		}
		// get the training job which name is test and its' type is tensorflow job
		trainingJob,err := client.Training().Get("test",types.TFTrainingJob))
        if err != nil {
            fmt.Printf("failed to get training job,reason: %v",err)
            return
        }
        fmt.Printf("training job status: %v\n",trainingJob.Status)
	}

repository: kubeflow/arena

gha_language: Go

repo_name: kubeflow/arena


text:
# My Django project

This is a Django project template with all necessary stuff to run a functional project without more changes.

## Features

- Organization model with some basic attributes.
- User model (from Abstract model) with foreign key to Organization model.
- User's email to login (`username` field is copied from email).
- Rest API support:
    - Login. Obtain access token and refresh access token.
    - Return user info with tokens at login.
    - CORS headers allowing all hosts.
    - Swagger docs.
- Tenant apps via [django-tenant-schemas](https://github.com/bernardopires/django-tenant-schemas).
    - __Organization__ model is the tenant base.
    - `core` app is shared (in `public` schema).
    - Use `migrate_schemas` instead of built-in `migrate` command.
    - Custom middleware to select `schema_name` from the request's header (`X-DTS-HEADER`). Default schema is `public`.

## Usage

You must have installed Django on your system to use `django-admin` command.

1. Create a new project by running:
```
django-admin startproject --template https://github.com/christianmtr/my_django_template/archive/master.zip new_django_project .
```

2. Create and active an virtual environment:
```
python -m venv venv
source venv/bin/activate
```
> Only works with Python 3.X, use `python3` if is necessary.

3. Change the database parameters in `settings.py` at line 77.

4. Install dependencies from `requirements.txt` by running:
```
pip install -r requirements.txt
```

5. Create migration files:
```
python manage.py makemigrations
```

6. Apply migrations:
```
python manage.py migrate_schemas
```

7. Create a super user specifying `schema` name:
```
createsuperuser --username=admin --schema=public
```

8. Run project:
```
python manage.py runserver
```

9. Enjoy =)

## Other behaviours and more features

Check out the other branches.


text:
## [v0.25.0]
> Unreleased

- **Breaking** - the API expects `opts.storePath` instead of `opts.store_path`.
- [#21] - Support installing from files. ([#257], [@zkochan])
- [#258] - Improve support for Windows. ([#259], [@zkochan])
- [#262] - Improve support for build scripts that use npm config variables. ([@zkochan])
- [#265] - Respect configuration from `.npmrc`. ([@zkochan])
- [#6] - Use junctions on Windows. ([#269], [@zkochan])
- [#270] - Support basic authorization. ([#278], [@leipert])
- [#144] - Uninstall support. ([#268], [@zkochan])
- [#23] - Reimplement bin/pnpm to .js. ([#268], [@zkochan])
- [#82] - Lock store when running commands. ([#268], [@zkochan])
- [#214] - Possibility to use a global store by starting the `store-path` config value with `~/`. The `~/` means the path will be relative to the `HOME` directory. ([#268], [@zkochan])

[#6]: https://github.com/rstacruz/pnpm/issues/6
[#21]: https://github.com/rstacruz/pnpm/issues/21
[#23]: https://github.com/rstacruz/pnpm/issues/23
[#82]: https://github.com/rstacruz/pnpm/issues/82
[#144]: https://github.com/rstacruz/pnpm/issues/144
[#214]: https://github.com/rstacruz/pnpm/issues/214
[#257]: https://github.com/rstacruz/pnpm/issues/257
[#258]: https://github.com/rstacruz/pnpm/issues/258
[#259]: https://github.com/rstacruz/pnpm/issues/259
[#262]: https://github.com/rstacruz/pnpm/issues/262
[#265]: https://github.com/rstacruz/pnpm/issues/265
[#268]: https://github.com/rstacruz/pnpm/issues/268
[#269]: https://github.com/rstacruz/pnpm/issues/269
[#270]: https://github.com/rstacruz/pnpm/issues/270
[#278]: https://github.com/rstacruz/pnpm/pull/278
[@leipert]: https://github.com/leipert
[v0.25.0]: https://github.com/rstacruz/pnpm/compare/v0.24.0...v0.25.0

## [v0.24.0]
> Jul 17, 2016

- [#180] - Add `--debug` to `--help`. ([@PeterDaveHello])
- [#39] - Support `optionalDependencies`. ([#256], [@zkochan])

[#39]: https://github.com/rstacruz/pnpm/issues/39
[#180]: https://github.com/rstacruz/pnpm/issues/180
[#256]: https://github.com/rstacruz/pnpm/issues/256
[@PeterDaveHello]: https://github.com/PeterDaveHello
[v0.24.0]: https://github.com/rstacruz/pnpm/compare/v0.23.0...v0.24.0

## [v0.23.0]
> Jul 12, 2016

- [#246] - Fix infinite loop issue on Windows.
- [#50] - Fix post-install script not being executed. ([#241], [@zkochan])
- [#237] - Fix some issues with nested scope packages. ([@zkochan])
- [#242] - Fix cases when .bin binstubs aren't created. ([#243], [@zkochan])
- [#244] - Use `--preserve-symlinks` on binstubs. ([#245], [@zkochan])

[#246]: https://github.com/rstacruz/pnpm/issues/246
[#50]: https://github.com/rstacruz/pnpm/issues/50
[#241]: https://github.com/rstacruz/pnpm/issues/241
[#237]: https://github.com/rstacruz/pnpm/issues/237
[#242]: https://github.com/rstacruz/pnpm/issues/242
[#243]: https://github.com/rstacruz/pnpm/issues/243
[#244]: https://github.com/rstacruz/pnpm/issues/244
[#245]: https://github.com/rstacruz/pnpm/issues/245
[@zkochan]: https://github.com/zkochan
[v0.23.0]: https://github.com/rstacruz/pnpm/compare/v0.22.0...v0.23.0

## [v0.22.1]
> Jun 19, 2016

- [#200] - Add support for `--ignore-scripts`. ([@ratson])
- [#199] - Add support for GitHub packages. ([@andreypopp])
- [#167], [#105] - Add support for private npm modules. ([#161], [@rexxars])

[#105]: https://github.com/rstacruz/pnpm/issues/105
[#161]: https://github.com/rstacruz/pnpm/issues/161
[#167]: https://github.com/rstacruz/pnpm/issues/167
[#199]: https://github.com/rstacruz/pnpm/issues/199
[#200]: https://github.com/rstacruz/pnpm/issues/200
[@ratson]: https://github.com/ratson
[@andreypopp]: https://github.com/andreypopp
[@rexxars]: https://github.com/rexxars
[v0.22.1]: https://github.com/rstacruz/pnpm/compare/v0.21.0...v0.22.1

## [v0.21.0]
> Apr  6, 2016

- [#174] - Fix some rare symlink problems.

[#174]: https://github.com/rstacruz/pnpm/issues/174
[v0.21.0]: https://github.com/rstacruz/pnpm/compare/v0.20.0...v0.21.0

## [v0.20.0]
> Apr  3, 2016

- [#155] - Print user-friendly errors when `package.json` isn't present.

[#155]: https://github.com/rstacruz/pnpm/issues/155
[v0.20.0]: https://github.com/rstacruz/pnpm/compare/v0.19.0...v0.20.0

## [v0.19.0]
> Mar 22, 2016

- [#78] - Fix symlink installation errors. ([#138], [@misterbyrne])

[#78]: https://github.com/rstacruz/pnpm/issues/78
[#138]: https://github.com/rstacruz/pnpm/issues/138
[@misterbyrne]: https://github.com/misterbyrne
[v0.19.0]: https://github.com/rstacruz/pnpm/compare/v1.18.0...v0.19.0

## [v0.18.0]
> Feb 12, 2016

- [#107] - sort dependencies in `--save`. ([@iamstarkov])
- [#93] - (internal) Resolve store_path. ([@kesla])
- [#94] - Fix `--production`. ([@kesla])
- [#86] - Enable HTTPS keepalive. ([@fengmk2])
- [#81] - Allow installing new versions of existing deps.

[#81]: https://github.com/rstacruz/pnpm/issues/81
[#86]: https://github.com/rstacruz/pnpm/issues/86
[#93]: https://github.com/rstacruz/pnpm/issues/93
[#94]: https://github.com/rstacruz/pnpm/issues/94
[#107]: https://github.com/rstacruz/pnpm/issues/107
[@kesla]: https://github.com/kesla
[@fengmk2]: https://github.com/fengmk2
[@iamstarkov]: https://github.com/iamstarkov
[v0.18.0]: https://github.com/rstacruz/pnpm/compare/v0.17.0...v0.18.0

## [v0.17.0]
> Feb  3, 2016

- [#45] - Improve support for 3rd-party registries like GemFury. ([@misterbyrne])
- [#80] - Use official npm registry endpoints.
- [#76] - Fix `pnpm --help`. ([@asbjornenge])

[v0.17.0]: https://github.com/rstacruz/pnpm/compare/v0.16.0...v0.17.0

## [v0.16.0]
> Feb  2, 2016

- [#74] - The package has been renamed from `pnpm.js` to `pnpm`. Update accordingly!
- No functional changes since v0.15.0.

[v0.16.0]: https://github.com/rstacruz/pnpm/compare/v0.15.0...v0.16.0

## [v0.15.0]
> Feb  2, 2016

- [#72] - Expose a programatic API via `require('pnpm')` (not documented for now).
- [#73] - Fix Node v0.12 compatibility.

[v0.15.0]: https://github.com/rstacruz/pnpm/compare/v0.14.0...v0.15.0

## [v0.14.0]
> Feb  1, 2016

- [#6], [#64] - Experimental Windows support.
- Documentation is now available at <http://ricostacruz.com/pnpm>.

[v0.14.0]: https://github.com/rstacruz/pnpm/compare/v0.13.0...v0.14.0

## [v0.13.0]
> Feb 1, 2016

- **Semi-breaking** - store format was slightly changed (to support peer dependencies, [#46]). pnpm will continue to be compatible with the old store format, but rebuilding `node_modules` is recommended to take advantage of new features.
- [#41] - Support `--save`, `--save-dev`, `--save-optional` and `--save-exact`. ([@davej])
- [#46] - Support modules being able to `require()` their peer dependencies (aka, emulate npm3-style flatness)
- [#57] - Support simpler Windows terminals.
- Improve logging appearance (show which packages are being fetched and which are queued).

[v0.13.0]: https://github.com/rstacruz/pnpm/compare/v0.12.1...v0.13.0

## [v0.12.0]
> Jan 31, 2016

- **Semi-breaking** - store format was slightly changed. pnpm will continue to be compatible with the old store format, but rebuilding `node_modules` is recommended to take advantage of new features.
- [#38] - Allow compatibility with npm utilities:
  - npm dedupe
  - npm shrinkwrap
  - npm prune
  - npm ls
  - npm rebuild

[v0.12.0]: https://github.com/rstacruz/pnpm/compare/v0.11.1...v0.12.0

## [v0.11.1]
> Jan 31, 2016

- [#9], [#36] - Support exact versions in scoped packages.

[v0.11.1]: https://github.com/rstacruz/pnpm/compare/v0.11.0...v0.11.1

## [v0.11.0]
> Jan 31, 2016

- [#24], [#34] - Limit download concurrency.
- [#10], [#35] - Allow custom registries (`npm config set registry http://npmjs.eu`).

[v0.11.0]: https://github.com/rstacruz/pnpm/compare/v0.10.1...v0.11.0

## [v0.10.1]
> Jan 30, 2016

- [#33] - Fix instances of running pnpm in directories without package.json.

[v0.10.1]: https://github.com/rstacruz/pnpm/compare/v0.10.0...v0.10.1

## [v0.10.0]
> Jan 30, 2016

- [#32] - Install from tarballs (`pnpm i http://site.com/package.tgz`).

[v0.10.0]: https://github.com/rstacruz/pnpm/compare/v0.9.0...v0.10.0

## [v0.9.0]
> Jan 30, 2016

- [#31] - Improve `bundleDependencies` support.

[v0.9.0]: https://github.com/rstacruz/pnpm/compare/v0.8.2...v0.9.0

## [v0.8.2]
> Jan 30, 2016

- Fix using `pnpm install` from dirs without package.json.

[v0.8.2]: https://github.com/rstacruz/pnpm/compare/v0.8.1...v0.8.2

## [v0.8.1]
> Jan 30, 2016

- [#25] - Improve `node-gyp` support (with preliminary Windows support).

[v0.8.1]: https://github.com/rstacruz/pnpm/compare/v0.8.0...v0.8.1

## [v0.8.0]
> Jan 30, 2016

- [#25] - Support `node-gyp`.

[v0.8.0]: https://github.com/rstacruz/pnpm/compare/v0.7.0...v0.8.0

## [v0.7.0]
> Jan 30, 2016

- [#18] - Support lifecycle hooks and compiled modules.

[v0.7.0]: https://github.com/rstacruz/pnpm/compare/v0.6.1...v0.7.0

## [v0.6.1]
> Jan 30, 2016

- [#17] - You can now safely rebuild from interrupted `pnpm install`s and pnpm will pick up where it left off.
- [#16] - Add support for `bundleDependencies`.
- Throw errors when doing `pnpm i github/repo`—this isn't supported yet (but will be!).

[v0.6.1]: https://github.com/rstacruz/pnpm/compare/v0.5.0...v0.6.1

## [v0.5.0]
> Jan 30, 2016

- Support scoped modules without version spec (eg, `pnpm i [@rstacruz]/tap-spec`).
- Lots of internal cleanups.

[v0.5.0]: https://github.com/rstacruz/pnpm/compare/v0.4.1...v0.5.0

## [v0.4.1]
> Jan 29, 2016

- [#11] - Fix using multiple scoped modules from the same scope.

[v0.4.1]: https://github.com/rstacruz/pnpm/compare/v0.4.0...v0.4.1

## [v0.4.0]
> Jan 29, 2016

- [#9] - Add preliminary support for scoped modules. ([#11], [@indexzero])

[v0.4.0]: https://github.com/rstacruz/pnpm/compare/v0.3.0...v0.4.0

## [v0.3.0]
> Jan 29, 2016

- Warn on unsupported flags (eg, `pnpm i --save x`).
- Cleanups and refactoring.

[v0.3.0]: https://github.com/rstacruz/pnpm/compare/v0.2.2...v0.3.0

## [v0.2.2]
> Jan 28, 2016

- Fix dependency problems.

[v0.2.2]: https://github.com/rstacruz/pnpm/compare/v0.2.1...v0.2.2

## [v0.2.1]
> Jan 28, 2016

- Fix "can't find module 'debug'" error.

[v0.2.1]: https://github.com/rstacruz/pnpm/compare/v0.2.0...v0.2.1

## [v0.2.0]
> Jan 28, 2016

- Improve atomicness of operations.
- Symlink bins into `node_modules/.bin`.

[v0.2.0]: https://github.com/rstacruz/pnpm/compare/v0.1.0...v0.2.0

## [v0.1.0]
> Jan 28, 2016

- Initial preview release.

[v0.1.0]: https://github.com/rstacruz/pnpm/blob/v0.1.0

[#10]: https://github.com/rstacruz/pnpm/issues/10
[#11]: https://github.com/rstacruz/pnpm/issues/11
[#16]: https://github.com/rstacruz/pnpm/issues/16
[#17]: https://github.com/rstacruz/pnpm/issues/17
[#18]: https://github.com/rstacruz/pnpm/issues/18
[#24]: https://github.com/rstacruz/pnpm/issues/24
[#25]: https://github.com/rstacruz/pnpm/issues/25
[#31]: https://github.com/rstacruz/pnpm/issues/31
[#32]: https://github.com/rstacruz/pnpm/issues/32
[#33]: https://github.com/rstacruz/pnpm/issues/33
[#34]: https://github.com/rstacruz/pnpm/issues/34
[#35]: https://github.com/rstacruz/pnpm/issues/35
[#36]: https://github.com/rstacruz/pnpm/issues/36
[#38]: https://github.com/rstacruz/pnpm/issues/38
[#41]: https://github.com/rstacruz/pnpm/issues/41
[#45]: https://github.com/rstacruz/pnpm/issues/45
[#46]: https://github.com/rstacruz/pnpm/issues/46
[#57]: https://github.com/rstacruz/pnpm/issues/57
[#64]: https://github.com/rstacruz/pnpm/issues/64
[#6]: https://github.com/rstacruz/pnpm/issues/6
[#72]: https://github.com/rstacruz/pnpm/issues/72
[#73]: https://github.com/rstacruz/pnpm/issues/73
[#74]: https://github.com/rstacruz/pnpm/issues/74
[#76]: https://github.com/rstacruz/pnpm/issues/76
[#80]: https://github.com/rstacruz/pnpm/issues/80
[#9]: https://github.com/rstacruz/pnpm/issues/9
[@asbjornenge]: https://github.com/asbjornenge
[@davej]: https://github.com/davej
[@indexzero]: https://github.com/indexzero
[@rstacruz]: https://github.com/rstacruz

repository: piscisaureus/pnpm

repo_name: piscisaureus/pnpm


text:
[![GitHub top language](https://img.shields.io/github/languages/top/Marvel-Face-Off/MFO.svg?colorB=EFDF70&style=plastic)](https://github.com/Marvel-Face-Off/MFO)
[![GitHub issues](https://img.shields.io/github/issues/Marvel-Face-Off/MFO.svg?&colorB=ff0000&style=plastic)](https://github.com/Marvel-Face-Off/MFO/issues)
[![GitHub pull requests](https://img.shields.io/github/issues-pr/Marvel-Face-Off/MFO.svg?colorB=1FBF14&style=plastic)](https://github.com/Marvel-Face-Off/MFO/pulls)
[![License (MIT)](https://img.shields.io/badge/license-MIT-blue.svg?style=plastic)](https://opensource.org/licenses/MIT)

# Marvel face Off

An icebreaker game where players must answer sets of random questions choosing between two random Marvel characters generated from the Marvel API.

Created by [Michael Haviv](https://github.com/mhaviv), [David Yim](https://github.com/yimd85) and [Jovan Williams](https://github.com/JWilliams35).

## Rules

With a group of friends, the person playing can take turns answering a randomly selected
question based on the the two random Marvel characters that appear. Once a character is clicked, the person playing can continue on or choose another group member to take his/her turn.

If the two characters that appear are unknown, the person playing is allowed to roll again (this does not apply to questions based on appearance).

## Deployment

https://marvel-face-off.herokuapp.com/

## Local Installation

```bash
$ git clone https://github.com/Marvel-Face-Off/MFO.git
$ cd MFO
$ npm install
$ npm start
```

## Project Structure

```
.
├── public             # Where static assets are served
│   └── index.html     ## The main HTML file that includes the React code
├── src                # Source code, including raw assets
│   ├── App.js         ## The top-level component for React
│   ├── fonts          ## Fonts(eot|otf|ttf|woff|woff2)
│   ├── images         ## Images (gif|png|jpe?g|svg|ico)
│   ├── components     ## Any shared components
│   │    └── Heroes.js ### Where API call is held
│   └── index.js       ## Webpack entry point / component mounting
└── questions.txt      # Where sets of game questions are held
```

## Technology Used

* [Marvel API](https://developer.marvel.com/) allows developers everywhere to access information about Marvel's vast library of comics.

* [React](https://reactjs.org/) A JavaScript library for building user interfaces.

## Credits

David Yim (contributor)
Michael Haviv (contributor)
Jovan Williams (contributor)

## Contribute
* Contributions are always welcome! Please read the [contribution guidelines](CONTRIBUTING.md) first.

## License
[![License (MIT)](https://img.shields.io/badge/license-MIT-blue.svg?style=plastic)](https://opensource.org/licenses/MIT)

* This frontend web application is available under the [MIT License](https://github.com/mhaviv/Marvel-Face-Off/MFO/blob/master/LICENSE.md)

repository: Marvel-Face-Off/MFO

repo_name: Marvel-Face-Off/MFO


text:
---
title: SRQ Am Series and Music Festival Registration
---

SRQ Am Series 2019 Registration

Get registered here! Registration slots are available at a First Come, First Serve Basis.

### **Make sure to print out and sign the waiver!**

Exceptional people can even send their completed waivers to <a href="mailto:{{<EMAIL_ADDRESS>| enunicode }}">{{<EMAIL_ADDRESS>| enunicode }} and will help make the world a better place let us get back to the skatepark faster.

A parent's signature is required on the waiver for any registrant under 18. Parents must be present at the time of competition for any registrant under age 14.

HELMETS ARE REQUIRED FOR ALL PARTICIPANTS IN THIS COMPETITION

We currently have spots for each of the following categories:
* 12 slots for Beginner
* 12 slots for Intermediate
* 12 slots for Advanced

You will be judged based on 5 separate categories:

* **Technical Difficulty** - 1 to 5 Points
* **Overall Style** - 1 to 5 Points
* **Execution of Tricks** - 1 to 5 Points
* **Creativity** - 1 to 5 Points
* **Number of Tricks Landed Successfully** - 1 to 5 Points

Each rider will get 2 runs at a length of 45 seconds per run. You will be rated based on your **combined** total score for both runs.

Each session will be judged by our most excellent panel of judgy folks.

Skate Registration

We currently have spots for each of the following categories:
* 12 slots for Beginner
* 12 slots for Intermediate
* 12 slots for Advanced

You will be judged based on 5 separate categories:

* **Technical Difficulty** - 1 to 5 Points
* **Overall Style** - 1 to 5 Points
* **Execution of Tricks** - 1 to 5 Points
* **Creativity** - 1 to 5 Points
* **Number of Tricks Landed Successfully** - 1 to 5 Points

Each rider will get 2 runs at a length of 45 seconds per run. You will be rated based on your **combined** total score for both runs.

Each session will be judged by our most excellent panel of judgy folks.

BMX Registration

repository: thursby/coastline-site

gha_language: JavaScript

repo_name: thursby/coastline-site


text:
# @blockly/renderer-inline-row-separators [![Built on Blockly](https://tinyurl.com/built-on-blockly)](https://github.com/google/blockly)

A [Blockly](https://www.npmjs.com/package/blockly) plugin to create a renderer that treats dummy inputs like row separators, allowing block designers to arrange multiple inline value input connectors on separate rows by inserting dummy inputs between them. Example blocks demonstrating the feature are provided, as well as a function to add the feature to your own renderer.

## Installation

### Yarn
```
yarn add @blockly/renderer-inline-row-separators
```

### npm
```
npm install @blockly/renderer-inline-row-separators --save
```

## Usage

### Using the modified thrasos renderer

This plugin registers a renderer called `"thrasos-inline-row-separators"` based on Blockly's built-in `"thrasos"` renderer. To use it, install the plugin, import it (with side effects), then refer to the new renderer in your workspace options:

```js
import * as Blockly from 'blockly';
import '@blockly/renderer-inline-row-separators'; // import with side effects.

function start() {
  const workspace = Blockly.inject('blocklyDiv', {
    toolbox: toolbox,
    renderer: 'thrasos-inline-row-separators',
  });
}
```

Initially, not much will be different. However, if you define any block types that insert a dummy input between two inline value inputs, the inline value input connectors will be rendered on separate lines:

```js
Blockly.common.defineBlocksWithJsonArray([
  {
    'type': 'inline_test',
    'message0': 'input A %1 %2 input B %3',
    'args0': [
      {'type': 'input_value', 'name': 'A'},
      {'type': 'input_dummy'},
      {'type': 'input_value', 'name': 'B'},
    ],
    'inputsInline': true,
  },
]);
```

![A Blockly block demonstrating inline value input connectors on separate rows.](readme-media/inline_row_example_screenshot.png)

### Using inline versions of built-in blocks

This plugin also defines some alternative versions of built-in Blockly blocks that demonstrate the feature: `"inline_text_join"`, `"inline_lists_create_with"`, and `"inline_procedures_defreturn"`. You can replace the built-in blocks `"text_join"`, `"lists_create_with"`, and `"procedures_defreturn"` with these alternatives (which allows you to use Blockly's built-in code generators with the inline version of these blocks) by importing and calling `overrideOldBlockDefinitions()`:

```js
import {overrideOldBlockDefinitions} from '@blockly/renderer-inline-row-separators';

overrideOldBlockDefinitions();
```

![A Blockly workspace showing blocks with inline value input connectors on separate rows.](readme-media/inline_row_separators_screenshot.png)

### Adding the row separator feature to other renderers

This plugin also exports a function called `addInlineRowSeparators` that you can use to add the same inline row separator feature to any class extending Blockly's Renderer, including your own.

```js
import * as Blockly from 'blockly';
import {addInlineRowSeparators} from '@blockly/renderer-inline-row-separators';

const NewRenderer = addInlineRowSeparators(YourRenderer, YourRenderInfo);
Blockly.blockRendering.register('new-renderer', NewRenderer);
```

## License

Apache 2.0

repository: google/blockly-samples

repo_name: google/blockly-samples


text:
---
id: custom-android-back-button-handling
title: Custom Android back button behavior
sidebar_label: Custom Android back button behavior
---

By default, when user presses the Android hardware back button, react-navigation will pop a screen or exit the app if there are no screens to pop. This is a sensible default behavior, but there are situations when you might want to implement custom handling.

> If you're looking for an easy-to-use solution, you can check out a community-developed package [react-navigation-backhandler](https://github.com/vonovak/react-navigation-backhandler). The following text shows what the package does under the cover.

As an example, consider a screen where user is selecting items in a list, and a "selection mode" is active. On a back button press, you would first want the "selection mode" to be deactivated, and the screen should be popped only on the second back button press. The following code snippet demonstrates the situation. We make use of [`BackHandler`](https://reactnative.dev/docs/backhandler.html) which comes with react-native and we [subscribe to navigation lifecycle updates](navigation-prop.md#addlistener-subscribe-to-updates-to-navigation-lifecycle) to add our custom `hardwareBackPress` listener.

Returning `true` from `onBackButtonPressAndroid` denotes that we have handled the event, and react-navigation's listener will not get called, thus not popping the screen. Returning `false` will cause the event to bubble up and react-navigation's listener will pop the screen.

```
import React from "react";
import { BackHandler } from "react-native";

class ScreenWithCustomBackBehavior extends React.Component {
  _didFocusSubscription;
  _willBlurSubscription;

  constructor(props) {
    super(props);
    this._didFocusSubscription = props.navigation.addListener('didFocus', payload =>
      BackHandler.addEventListener('hardwareBackPress', this.onBackButtonPressAndroid)
    );
  }

  componentDidMount() {
    this._willBlurSubscription = this.props.navigation.addListener('willBlur', payload =>
      BackHandler.removeEventListener('hardwareBackPress', this.onBackButtonPressAndroid)
    );
  }

  onBackButtonPressAndroid = () => {
    if (this.isSelectionModeEnabled()) {
      this.disableSelectionMode();
      return true;
    } else {
      return false;
    }
  };

  componentWillUnmount() {
    this._didFocusSubscription && this._didFocusSubscription.remove();
    this._willBlurSubscription && this._willBlurSubscription.remove();
  }

  render() {
    // ...
  }
}
```

The presented approach will work well for screens that are shown in a `StackNavigator`. Custom back button handling in other situations may not be supported at the moment (eg. A known case when this does not work is when you want to handle back button press in an open drawer. PRs for such use cases are welcome!).

### Why not use component lifecycle methods?

At first, you may be inclined to use `componentDidMount` to subscribe for the back press event and `componentWillUnmount` to unsubscribe. This approach will not work - learn more about this in [navigation lifecycle](navigation-lifecycle.md).


text:
# Kiln [![release](https://github.com/pivotal-cf/kiln/actions/workflows/release.yml/badge.svg)](https://github.com/pivotal-cf/kiln/actions/workflows/release.yml) [![Go Reference](https://pkg.go.dev/badge/github.com/pivotal-cf/kiln.svg)](https://pkg.go.dev/github.com/pivotal-cf/kiln/pkg)

_Kiln bakes tiles_

Kiln helps tile developers build products for [VMware Tanzu Operations Manager](https://network.tanzu.vmware.com/products/ops-manager/). It provides
an opinionated folder structure and templating capabilities. It is designed to be used
both in CI environments and in command-line to produce a tile.

More information for those just getting started can be found in the [Ops Manager Tile Developer Guide](https://docs.vmware.com/en/Tile-Developer-Guide/3.0/tile-dev-guide/index.html) .
Looking at an [example kiln tile](https://github.com/crhntr/hello-tile/tree/main) may also be helpful

## Installation

To install the `kiln` CLI
- install with Homebrew

  ```shell
  brew tap pivotal-cf/kiln https://github.com/pivotal-cf/kiln
  brew install kiln
  ```

- download from the [releases page](https://github.com/pivotal-cf/kiln/releases)

  ```shell
  export KILN_VERSION
  KILN_VERSION="$(curl -H "Accept: application/vnd.github.v3+json" 'https://api.github.com/repos/pivotal-cf/kiln/releases?per_page=1' | jq -r '.[0].name')"
  curl -L -o kiln "https://github.com/pivotal-cf/kiln/releases/download/${KILN_VERSION}/kiln-darwin-${KILN_VERSION}"
  # check the checksum
  cp kiln "$(go env GOPATH)/bin"
  kiln version
  ```

- build from source

  ```shell
  git clone git@github.com:pivotal-cf/kiln.git
  cd kiln
  git checkout 0.60.2
  ./install.sh
  ```

- copy from a Docker image (to another image)

  ```shell
  docker pull pivotalcfreleng/kiln:latest
  ```

   ```Dockerfile
  FROM pivotalcfreleng/kiln:latest as kiln

  FROM ubuntu
  COPY --from=kiln /kiln /usr/bin/kiln
  CMD /usr/bin/bash
   ```

## Subcommands

### `help`

```
Usage: kiln [options] <command> [<args>]
  --help, -h     bool  prints this usage information (default: false)
  --version, -v  bool  prints the kiln release version (default: false)

Commands:
  bake                     bakes a tile
  cache-compiled-releases  Cache compiled releases
  fetch                    fetches releases
  find-release-version     prints a json string of a remote release satisfying the Kilnfile version and stemcell constraints
  find-stemcell-version    prints the latest stemcell version from Pivnet using the stemcell type listed in the Kilnfile
  generate-osm-manifest    Print an OSM-format manifest.
  glaze                    Pin versions in Kilnfile to match lock.
  help                     prints this usage information
  publish                  publish tile on Pivnet
  release-notes            generates release notes from bosh-release release notes
  sync-with-local          update the Kilnfile.lock based on local releases
  test                     Test manifest for a product
  update-release           bumps a release to a new version
  update-stemcell          updates stemcell and release information in Kilnfile.lock
  upload-release           uploads a BOSH release to an s3 release_source
  validate                 validate Kilnfile and Kilnfile.lock
  version                  prints the kiln release version
```

### `bake`

It takes release and stemcell tarballs, metadata YAML, and JavaScript migrations
as inputs and produces an OpsMan-compatible tile as its output.

The produce a tile, you simply need to be within a tile directory and execute the following command:
```
$ kiln bake
```

This will ensure that you have the necessary releases by first calling `kiln fetch`.

Refer to the [example-tile](example-tile) for a complete example showing the
different features kiln supports.

  Additional bake options

##### `--allow-only-publishable-releases`

The `--allow-only-publishable-releases` flag should be used for development only
and allows additional releases other than those specified in the kilnfile.lock to
be included in the tile

##### `--bosh-variables-directory`

The `--bosh-variables-directory` flag can be used to include CredHub variable
declarations. You should prefer the use of variables rather than Ops Manager
secrets. Each `.yml` file in the directory should define a top-level `variables`
key.

This flag can be specified multiple times if you have organized your
variables into subdirectories for development convenience.

Example [variables](example-tile/bosh_variables) directory.

##### `--download-threads`

The `--download-threads` flag is for those using S3 as a BOSH release source.
This flag sets the number of parallel threads to download parts from S3

##### `--embed`

The `--embed` flag is for embedding any extra files or directories into the
tile. There are very few reasons a tile developer should want to do this, but if
you do, you can include these extra files here. The flag can be specified
multiple times to embed multiple files or directories.

##### `--forms-directory`

The `--forms-directory` flag takes a path to a directory that contains one
or more forms. The flag can be specified more than once.

To reference a form file in the directory you can use the `form`
template helper:

```
$ cat /path/to/metadata
---
form_types:
- $( form "first" )
```

Example [forms](example-tile/forms) directory.

##### `--icon`

The `--icon` flag takes a path to an icon file.

To include the base64'd representation of the icon you can use the `icon`
template helper:

```
$ cat /path/to/metadata
---
icon_image: $( icon )
```

##### `--instance-groups-directory`

The `--instance-groups-directory` flag takes a path to a directory that contains one
or more instance groups. The flag can be specified more than once.

To reference an instance group in the directory you can use the `instance_group`
template helper:

```
$ cat /path/to/metadata
---
job_types:
- $( instance_group "my-instance-group" )
```

Example [instance-groups](example-tile/instance_groups) directory.

##### `--jobs-directory`

The `--jobs-directory` flag takes a path to a directory that contains one
or more jobs. The flag can be specified more than once.

To reference a job file in the directory you can use the `job`
template helper:

```
$ cat /path/to/instance-group
---
templates:
- $( job "my-job" )
- $( job "my-aliased-job" )
- $( job "my-errand" )
```

Example [jobs](example-tile/jobs) directory.

You may find that you want to define different job files for the same BOSH job
with different properties. To do this you add an `alias` key to the job which
will be used in preference to the job name when resolving job references:

```
$ cat /path/to/my-aliased-job
---
name: my-job
alias: my-aliased-job
```

##### `--kilnfile`

The `--kilnfile` flag is required with kiln version v0.84.0 and later
The flag expects filepath to a Kilnfile (default: Kilnfile). This
file contain links to all the bosh sources used to build a tile

See the [Kilnfile](#kilnfile) section for more information on Kilnfile formatting

Tile authors will also need to include a Kilnfile.lock in the same directory
as the Kilnfile.

See the [Kilnfile.lock](#kilnfile-lock) section for more information on Kilnfile.lock formatting

##### `--metadata`

Specify a file path to a tile metadata file for the `--metadata` flag. This
metadata file will contain the contents of your tile configuration as specified
in the OpsManager tile development documentation.

##### `--metadata-only`

The `--metadata-only` flag outputs the generated metadata to stdout.
This flag cannot be used with `--output-file`.

##### `--migrations-directory`

If your tile has JavaScript migrations, then you will need to include the
`--migrations-directory` flag. This flag can be specified multiple times if you
have organized your migrations into subdirectories for development convenience.

##### `--no-confirm`

The `no-confirm` flag will delete extra releases in releases directory without prompting.
This flag defaults to `true`

##### `--output-file`

The `--output-file` flag takes a path to the location on the filesystem where
your tile will be created. The flag expects a full file name like
`tiles/my-tile-1.2.3-build.4.pivotal`.

Cannot be used with `--metadata-only`.

##### `--properties-directory`

The `--properties-directory` flag takes a path to a directory that contains one
or more blueprint property files. The flag can be specified more than once.

To reference a properties file in the directory you can use the `property`
template helper:

```
$ cat /path/to/metadata
---
property_blueprints:
- $( property "rep_password" )
```

Example [properties](example-tile/properties) directory.

##### `--releases-directory`

The `--releases-directory` flag takes a path to a directory that contains one or
many release tarballs. The flag can be specified more than once. This is
useful if you consume bosh releases as Concourse resources. Each release will
likely show up in the task as a separate directory. For example:

```
$ tree /path/to/releases
|-- first
|   |-- cflinuxfs2-release-1.166.0.tgz
|   `-- consul-release-190.tgz
`-- second
    `-- nats-release-22.tgz
```

To reference a release you can use the `release` template helper:

```
$ cat /path/to/metadata
---
releases:
- $( release "cflinuxfs2" )
- $( release "consul" )
- $( release "nats" )
```

Example kiln command line:

```
$ kiln bake \
    --version 2.0.0 \
    --metadata /path/to/metadata.yml \
    --releases-directory /path/to/releases/first \
    --releases-directory /path/to/releases/second \
    --stemcells-directory /path/to/stemcells/first \
    --stemcells-directory /path/to/stemcells/second \
    --output-file /path/to/cf-2.0.0-build.4.pivotal
```

##### `--runtime-configs-directory`

The `--runtime-configs-directory` flag takes a path to a directory that
contains one or more runtime config files. The flag can be specified
more than once.

To reference a runtime config in the directory you can use the `runtime_config`
template helper:

```
$ cat /path/to/metadata
---
runtime_configs:
- $( runtime_config "first-runtime-config" )
```

Example [runtime-configs](example-tile/runtime_configs) directory.

##### `--sha256`

The `--sha256` flag calculates the sha256 checksum of the output file

##### `--skip-fetch-directories`

The `--skip-fetch-directories` skips the automatic release fetching of
the specified release directories

##### `--stemcell-tarball` (Deprecated)

*Warning: `--stemcell-tarball` will be removed in a future version of kiln.
Use `--stemcells-directory` in the future.*

The `--stemcell-tarball` flag takes a path to a stemcell.

To include information about the stemcell in your metadata you can use the
`stemcell` template helper:

```
$ cat /path/to/metadata
---
stemcell_criteria: $( stemcell )
```

##### `--stemcells-directory`

The `--stemcells-directory` flag takes a path to a directory containing one
or more stemcells.

To include information about the stemcell in your metadata you can use the
`stemcell` template helper. It takes a single argument that specifies which
stemcell os.

The `stemcell` helper does not support multiple versions of the same operating
system currently.

```
$ cat /path/to/metadata
---
stemcell_criteria: $( stemcell "ubuntu-xenial" )
additional_stemcells_criteria:
- $( stemcell "windows" )
```

##### `--stub-releases`

For tile developers looking to get some quick feedback about their tile
metadata, the `--stub-releases` flag will skip including the release tarballs
into the built tile output. This should result in a much smaller file that
should upload much more quickly to OpsManager.

##### `--variable`

The `--variable` flag takes a `key=value` argument that allows you to specify
arbitrary variables for use in your metadata. The flag can be specified
more than once.

To reference a variable you can use the `variable` template helper:

```
$ cat /path/to/metadata
---
$( variable "some-variable" )
```

##### `--variables-file`

The `--variables-file` flag takes a path to a YAML file that contains arbitrary
variables for use in your metadata. The flag can be specified more than once.

To reference a variable you can use the `variable` template helper:

```
$ cat /path/to/metadata
---
$( variable "some-variable" )
```

Example [variables file](example-tile/variables.yml).

##### `--version`

The `--version` flag takes the version number you want your tile to become.

To reference the version you use the `version` template helper:

```
$ cat /path/to/metadata
---
product_version: $( version )
provides_product_versions:
- name: example
  version: $( version )
```

### `test`

The `test` command exercises to ginkgo tests under the `/<tile>/test/manifest` and `/<tile>/migrations` paths of the `pivotal/tas` repos (where `<tile>` is tas, ist, or tasw).

Running these tests require a docker daemon and ssh-agent to be running. If no ssh identity is added (check with `ssh-add -l`) , then `kiln test`
will add a ssh key in the following order, prompting for a passphrase if required:
```
	~/.ssh/id_rs
	~/.ssh/id_dsa
	~/.ssh/d_ecdsa
	~/.ssh/d_ed25519
	~/.ssh/dentity
```

The identity must have access to github.com/pivotal/ops-manager.

Here are command line examples:
```
$ cd ~/workspace/tas/ist
$ kiln test
```

```
cd ~
$ kiln test --verbose -tp ~/workspace/tas/ist --ginkgo-manifest-flags "-p -nodes 8 -v"
```

  Additional test options

##### `--ginkgo-manifest-flags`

The `--ginkgo-manifest-flags` flag can be used to pass through Ginkgo test flags. The defaults being passed through are `-r -p -slowSpecThreshold 15`. Pass `help` as a flag to retrieve the available options for the embeded version of ginkgo.

#### `--manifest-only`

The `--manifest-only` flag can be used to run only Manifest tests. If not passed, `kiln test` will run both Manifest and Migration tests by default.

#### `--migrations-only`

The `--migrations-only` flag can be used to run only Migration tests. If not passed, `kiln test` will run both Manifest and Migration tests by default.

##### `--tile-path`

The `--tile-path` (`-tp`) flag can be set the path the directory you wish to test. It defaults to the current working directory. For example
```
$ kiln test -tp ~/workspace/tas/ist
```

##### `--verbose`

The `--verbose` (`-v`) flag will log additional debugging info.

### `fetch`

The `fetch` command downloads bosh release tarballs specified in the Kilnfile and
Kilnfile.lock files to a local directory specified by the `--releases-directory` flag.

Kiln verifies that the checksum (SHA1) of the downloaded release matches
checksum specified for the release in the Kilnfile.lock file. If the checksums do
not match, then the releases that don't match will be deleted from disk. *Since
BOSH releases from different directors with the same packages result in complied
releases with different hashes this may result in some problems where if you
download a release that was compiled with a different director those releases
will be deleted.*

Kiln will not download releases if an existing release exists with the correct
release version and checksum.

## Kilnfile
A Kilnfile contains information about the bosh releases and stemcell used by
a particular tile

Example Kilnfile:
```yaml
---
slug: some-slug #optional but if included should match network.pivotal.io
release_sources:
- type: bosh.io
  releases:
- name: bpm
  version: '*'
stemcell_criteria:
  os: ubuntu-xenial
  version: "~621"
```

#### Supported release sources
##### Bosh.io
  ```yaml
  release_sources:
  - type: bosh.io
  ```
##### s3
```yaml
  release_sources:
  - type: s3
    id: unique-name
    publishable: true # if this bucket contains releases that are suitable to ship to customers
    bucket: some-bucket-in-s3
    region: us-east-1 # must be the region of the above bucket
    access_key_id: $(variable "s3_access_key_id") # Must have at least read permissions to bucket
    secret_access_key: $(variable "s3_secret_access_key")
    path_template: bosh-releases/compiled/{{.Name}}-{{.Version}}-{{.StemcellOS}}-{{.StemcellVersion}}.tgz # See Templating
```

##### github
```yaml
  - type: github
    id: optional-unique-name-defaults-to-github-org-name
    org: the-github-org
    github_token: $(variable "github_token")
```

##### artifactory
```yaml
  - type: artifactory
    id: unique-name
    artifactory_host: https://build-artifactory.your-artifactory-url.com
    repo: some-artifactory-repo
    publishable: true # if this repo contains releases that are suitable to ship to customers
    username: $(variable "artifactory_username")
    password: $(variable "artifactory_password")
    path_template: shared-releases/{{.Name}}-{{.Version}}-{{.StemcellOS}}-{{.StemcellVersion}}.tgz # See Templating
```

### Templating
#### Options
Kilnfile files support the following templating options:

- `{{.Name}}` for release name
- `{{.Version}}` for release version
- `{{.StemcellOS}}` for stemcell OS
- `{{.StemcellVersion}}` for stemcell version

- There's also access to a `trimSuffix` helper (e.g. `{{trimSuffix .Name "-release"}}`)

#### Functions
##### `select`

The `select` function allows you to pluck values for nested fields from a
template helper.

For instance, this section in our example tile:

```yaml
my_release_version: $( release "my-release" | select "version" )
```

Results in:

```yaml
my_release_version: 1.2.3
```

#### Variable Interpolation

```yaml
release_sources:
  - type: s3
    compiled: true
    bucket: compiled-releases
    region: us-west-1
    access_key_id: $(variable "aws_access_key_id")
    secret_access_key: $(variable "aws_secret_access_key")
    path_template: 2.6/{{trimSuffix .Name "-release"}}/{{.Name}}-{{.Version}}-{{.StemcellOS}}-{{.StemcellVersion}}.tgz
```

*Credentials like S3 keys are not stored in git repos. To support separating
that information from non-sensitive configuration, you can reference variables
like you do in tile config.*

```yaml
---
aws_access_key_id: SOME_REALLY_SECRET_ID
aws_secret_access_key: SOME_REALLY_SECRET_KEY
```

Interpolating this file in kiln would look something like this.

```bash
kiln bake --kilnfile random-Kilnfile --variables-file <(lpass show --notes 'pas-releng-fetch-releases')
```

### Kilnfile.lock

The Kilnfile.lock file name is expected to be a file in the same directory as the
Kilnfile with `lock` as as the filename extension.

This file contains the full list of specific versions of all releases, shas, and sources for
bosh releases that will go into the tile as well as the target stemcell.

The file has two top level members `releases` and `stemcell_criteria`.

The `releases` member is an array of members with each element having the following members.
- `name`: bosh release name
- `sha1`: checksum of the tarball
- `version`: semantic version of the release
- `remote_source`: the resource-type for bosh.io or the id for the other types
- `remote_path`: the path that where the bosh release is stored

The `stemcell_criteria ` member is defines the stemcell used to generate the tile
- `os`: the stemcell os used (e.g. ubuntu-xenial)
- `version`: semantic version of the stemcell

Example Kilnfile.lock :
```yaml
releases:
- name: bpm
  sha1: 86675f90d66f7018c57f4ae0312f1b3834dd58c9
  version: 1.1.18
  remote_source: bosh.io
  remote_path: https://bosh.io/d/github.com/cloudfoundry/bpm-release?v=1.1.18
- name: backup-and-restore-sdk
  sha1: 0f48faa2f85297043e5201e2200567c2fe5a9f9a
  version: 1.18.84
  remote_source: unique-name # this could be artifactory or s3
  remote_path: bosh-releases/compiled/backup-and-restore-sdk-1.18.84-ubuntu-jammy-1.179.tgz
- name: hello-release
  sha1: 06500a2002f6e14f6c258b7ee7044761a28d3d5a
  version: 0.1.5
  remote_source: the-github-org
  remote_path: https://github.com/crhntr/hello-release/releases/download/v0.1.5/hello-release-v0.1.5.tgz
stemcell_criteria:
  os: ubuntu-xenial
  version: "621.0"
```

repository: pivotal-cf/kiln

repo_name: pivotal-cf/kiln


text:
# Monte Carlo Simulation for Forecasting Cycle Times

I came across some examples and plugins (see references) for estimating the cycle times in a Kanban system.
So my goal was to build the same thing with a Python Jupyter Notebook.

The parts:
- The Data Exploration Notebook ([notebooks/analyse_data.ipynb](notebooks/analyse_data.ipynb)) can be used to examine the data.
- The Forecasting Notebook ([notebooks/forecasting_with_monte_carlo.ipynb](notebooks/forecasting_with_monte_carlo.ipynb)) is used to do a
Monte Carlo  simulation for the cycle times.
- The [data](notebooks/data.csv) as CSV file.
    - *id* => the JIRA issue id (only the number part).
    - *grp* => the project part from the JIRA issue as number
    - *cycle_time_days* => cycle time in days for this JIRA issue (`finish date - start date = cycle time days`).
    - *created_date* => when the issue was created

![](simulation.png)
![](dens.png)

## Getting Started

All the required Python packages can be installed with `pipenv`.

### Project Setup

First you nee to install pipenv.

```bash
$ pip install --user pipenv
```

Install all the required packages

```bash
$ pipenv install --dev
```

### Run the Notebook

```bash
pipenv run jupyter-lab
```

## CI Build
![CI Build](https://github.com/rueedlinger/monte-carlo-simulation/workflows/CI%20Build/badge.svg)

## References

-	https://www.actionableagile.com/
-	https://kanbanize.com/blog/monte-carlo-simulations/


text:
# naughtydog-ps3save-decrypter
A tool to decrypt Naughty Dog PS3 save-games (The Last of Us, Uncharted 2, Uncharted 3)

```
USAGE: ./naughtydog-ps3save-decrypter [option] filename

OPTIONS        Explanation:
 -d            Decrypt File
 -e            Encrypt File
```

### Hashes

**Note:** the tool also updates the CRC32 and SHA1 HMAC integrity hashes.

#### CRC32

```
[Update CRC32 checksum for USR-DATA (Required)]
set [block_length]:read(0x58C,4)
set [block_length]:[block_length]+0x587
set range:0x58C,[block_length]
set [hash]:crc32
write at 0x588:[hash]
```

#### SHA1 HMAC

```
[Update HMAC SHA1 checksum for USR-DATA (Required)]
set pointer:EOF-0x1F
set range:0x000008,pointer
set [hash]:hmac_sha1("xM;6X%/p^L/:}-5QoA+K8:F*M!~sb(WK<E%6sW_un0a[7Gm6,()kHoXY+yI/s;Ba")
set pointer:EOF-0x1F
write next (0):[hash]
```

### Credits

This tool is based (reversed) on the original `tlou_save_data_decrypter` by Red-EyeX32 and aerosoul94