text:
Plugin @PLUGIN@
===============

This plugin allows to associate Jira issues to Git commits.

It can be configured per project whether the Jira integration is
enabled or not. To enable the Jira integration for a project the
project must have the following entry in its `project.config` file in
the `refs/meta/config` branch:

```
  [plugin "its-jira"]
    enabled = true
```

If `plugin.its-jira.enabled` is not specified in the `project.config` file
the value is inherited from the parent project. If it is also not set
on any parent project the Jira integration is disabled for this
project.

By setting `plugin.its-jira.enabled` to true in the `project.config` of the
`All-Projects` project the Jira integration can be enabled by default
for all projects. During the initialization of the plugin you are asked
if the Jira integration should be enabled by default for all projects
and if yes this setting in the `project.config` of the `All-Projects`
project is done automatically.

If child projects must not be allowed to disable the Jira integration
a project can enforce the Jira integration for all child projects by
setting `plugin.its-jira.enabled` to `enforced`.

On the project info screen there is a dropdown list for the
`plugin.its-jira.enabled` parameter which offers the values `true`,
`false`, `enforced` and `INHERIT`. Project owners can change this
parameter and save it. If the Jira integration is enforced by a parent
project the dropdown list is disabled.

The Jira integration can be limited to specific branches by setting
`plugin.its-jira.branch`. The branches may be configured using explicit
branch names, ref patterns, or regular expressions. Multiple branches
may be specified.

E.g. to limit the Jira integration to the `master` branch and all
stable branches the following could be configured:

```
  [plugin "its-jira"]
    enabled = true
    branch = refs/heads/master
    branch = ^refs/heads/stable-.*
```

Comment links
----------------

Git commits are associated to Jira issues reusing the existing Gerrit
[commitLink configuration][1] to extract the issue-id from the commit
messages.

[1]: ../../../Documentation/config-gerrit.html#__a_id_commentlink_a_section_commentlink

Additionally you need to specify the enforcement policy for git commits
with regards to issue-tracker associations; the following values are supported:

MANDATORY
:	 One or more issue-ids are required in the git commit message, otherwise
	 the git push will be rejected.

SUGGESTED
:	 Whenever a git commit message does not contain any issue-id,
	 a warning message is displayed as a suggestion on the client.

OPTIONAL
:	 Issue-ids are linked when found in a git commit message. No warning is
	 displayed otherwise.

Example:

    [commentLink "its-jira"]
    match = (\\[[A-Z][A-Z]+-[1-9][0-9]*\\])
    html = "$1"
    association = SUGGESTED

Once a Git commit with a comment link is detected, the Jira issue ID
is extracted and a new comment is added to the issue, pointing back to
the original Git commit.

Jira connectivity
-----------------

In order for Gerrit to connect to Jira/SOAP-API URL and credentials
are required in your `gerrit.config` / `secure.config` under the
`[its-jira]` section.

Example:

    [its-jira]
    url=http://jira.example.com
    username=admin
    password=jirapass

Jira credentials and connectivity details are asked and verified during the Gerrit init.

Comment configuration
---------------------

It is possible to choose which kind of Gerrit event will trigger the plugin to comment on
the Jira issue by adding the following in your `gerrit.config` file under the `[its-jira]` section:

commentOnChangeAbandoned
:	If true, abandoning a change adds a comment to the issue.

commentOnChangeCreated
:	If true, creating a change adds a comment to the issue.

commentOnChangeMerged
:	If true, merging a change adds a comment to the issue.

commentOnChangeRestored
:	If true, restoring an abandoned change adds a comment to the issue.

commentOnCommentAdded
:	If true, adding a comment or reviewing a change adds a comment to the issue.

commentOnFirstLinkedPatchSetCreated
:	If true, creating a patch set for a change adds a comment to the issue if
	the issue has not been mentioned in previous patch sets of the same change.

commentOnPatchSetCreated
:	If true, creating a patch set for a change adds a comment to the issue.

commentOnRefUpdatedGitWeb
:	If true, updating a ref adds a comment to the issue.

By default all parameters are set to true.

Example:

    [its-jira]
    commentOnCommentAdded=false
    commentOnRefUpdatedGitWeb=false

Gerrit init integration
-----------------------

The Jira plugin comes with a Gerrit init step that simplifies the
initial configuration. It guides through the configuration of the Jira
integration and checks the connectivity.

Gerrit init example:

    *** Jira Integration
    ***

    Issue tracker integration for all projects? [DISABLED/?]: enabled
    Branches for which the issue tracker integration should be enabled (ref, ref pattern or regular expression) [refs/heads/*]:

    *** Jira connectivity
    ***

    Jira URL (empty to skip)       [http://jira.example.com]:
    Jira username                  [admin]:
    Change admin's password        [y/N]? y
    admin's password               : *****
                  confirm password : *****
    Test connectivity to http://jira.example.com [y/N]: y
    Checking Jira connectivity ... [OK]

    *** Jira issue-tracking association
    ***

    Jira issue-Id regex            [([A-Z]+-[0-9]+)]:
    Issue-id enforced in commit message [MANDATORY/?]: ?
           Supported options are:
           mandatory
           suggested
           optional
    Issue-id enforced in commit message [MANDATORY/?]: suggested

GitWeb integration
----------------

When Gerrit gitweb is configured, an additional direct link from Jira to GitWeb
will be created, pointing exactly to the Git commit ID containing the Jira issue ID.

Issues workflow automation
--------------------------

Jira plugin is able to automate status transition on the issues based on
code-review actions performed on Gerrit; actions are performed on Jira using
the username/password provided during Gerrit init.
Transition automation is driven by `$GERRIT_SITE/etc/issue-state-transition.config`
file.

Syntax of the status transition configuration file is the following:

    [action "<issue-status-action>"]
    change=<state-change-type>
    verified=<verified-value>
    code-review=

`<issue-status-action>`
:	Action to be performed on the Jira issue when all the condition in the stanza are met.

`<state-change-type>`
:	Gerrit state change type on which the action will be triggered.
	Possible values are: `created`, `commented`, `merged`, `abandoned`,
	`restored`

`<verified-value>`
:	Verified label added on the Gerrit change with a value from -1 to +1

`<code-review-value>`
:	Code-Review label added on the Gerrit change with a value from -2 to +2

Note: multiple conditions in the action stanza are possible but at least one must be present.

Example:

    [action "Start Progress"]
    change=created

    [action "Resolve Issue"]
    verified=+1
    code-review=+2

    [action "Close Issue"]
    change=merged

    [action "Stop Progress"]
    change=abandoned

The above example defines four status transitions on Jira, based on the following conditions:

* Whenever a new Change is created on Gerrit, start progress on the Jira issue
* Whenever a change is verified and reviewed with +2, set the Jira issue to resolved
* Whenever a change is merged to the branch, close the Jira issue
* Whenever a change is abandoned, stop the progress on the Jira issue

repository: barqshasbite/its-jira

repo_name: barqshasbite/its-jira


text:
# HEAT

This project relates to the paper "HEAT: Heterogeneous Entity-level Attention for Entity Typing".

This project provides an attention-based neural network model for the entity-level typing task. It processes heterogeneous data and learns representations from them, including the name, relevant paragraphs, and relevant image features.

While **Mention-level Entity Typing** infers the types of a mention that are supported by its textual contexts, **Entity-level Typing** infers types of an entity by considering all types supported by data.

### Requirements and initialization

- PyTorch version >= 1.7
- Python version >= 3.7
- transformers >= 3.3
- a GPU with 11GB graphic RAM if run with the BiLSTM encoder
- a GPU with 32GB graphic RAM if run with the BERT encoder

Run `python init.py` to download datasets. Run `bash run.sh` to train the model with each dataset.

### Usage

- `-task` specifies the task id
- `-dataset` specifies the dataset name
- `-text_encoder` specifies the text encoder in {'bert', 'bert_freeze', 'lstm'}
- `-remove_name, -remove_para, -remove_img` make the model not use corresponding modules
- `-without_token_attention, -without_cross_modal_attention` make the model not use corresponding attention layers
- `-seed` specifies the random seed id
- `-consistency` makes the model do consistency training together
- `-labeled_num` limits the labeled samples number
- `-cpu` runs on cpu
- Other hyper-parameters are set in `config.py`

### Datasets

Four public datasets have been processed for the Entity-level typing with heterogeneous data task:

- TypeNet: aligns  Freebase  types  to  noun  synsets from the WordNet hierarchy and eliminate types that are  either  very  specific  or  very  rare.  The  original dataset  consists  of  more than  two million  mentions with the name and contexts. Our processed TypeNet consists of more than half a million entities with the name and relevant paragraphs. [download](http://lfs.aminer.cn/misc/moocdata/data/type_net.zip)
- MedMentions: contains annotations for a wide diversity of entities in the biomedical domain. The original dataset consists of nearly $250$ thousand mentions. Our processed MedMentions consists of more than 50 thousand entities with the name and relevant paragraphs. [download](http://lfs.aminer.cn/misc/moocdata/data/med_mentions.zip)
- Flowers: (Oxford Flowers-102) provides text descriptions for each flower image. The objective is to classify the fine-grained flower name of the sample. We keep the original splits and use the cross-entropy loss since each sample has only one positive type. [download](http://lfs.aminer.cn/misc/moocdata/data/flowers.zip)
- Birds: (Caltech-UCSD  Birds) provides  text descriptions for each bird image. The objective is to classify the fine-grained bird name of the sample. We also keep the original splits and use the cross-entropy loss since each sample has only one positive type. [download](http://lfs.aminer.cn/misc/moocdata/data/birds.zip)

Files in each dataset:

- `data.pkl` contains the name, raw paragraphs, and each typing task's labels for an entity
- `data_txt.pkl` is generated by `data_loader.py` and contains the tokenized indexes of the name and paragraphs
- `data_img.pkl` (optional) contains each entity's relevant image features
- `split.pkl` (optional) contains the split information of train/valid/test sets by entity's name
- `types.json` contains the name of each type
- `hierarchies.json` contains the taxonomy between types

license: MIT

branch_name: refs/heads/main

extension: md

license_type: permissive


text:
# Inhalt
* Einleitung
* Stand der Technik
* Anforderungsdokumentation
* Architekturbeschreibung
* Implementierung
* Test und Usability
* Zusammenfassung

![Bewertungskriterien](markdown/images/bewertungskriterien.JPG)

# party-popper
App for finding and exploring nearby events and parties 🎉

## Idea

A mobile application in which the current events / parties in the surrounding area
are displayed. These events get hotter depending on how many users have agreed to them. The events are created by clubs, bars etc. with their special business accounts. Users can follow one another to see where their friends are celebrating today. In addition, one can rate the organizers or follow them to receive updates and notifications.

### Must have ...
* User registration and login
* Organizer (business) registration and login
* List of current events in the surrounding  area
* Add events

### Should have ...
* Join events
* Rate organizers
* Follow or block organizers
* Filter events
* Search events

### Could have ...
* Follow other users
* Map of current events
* private events by regular users

### Won't have ...
* User tailored views
* QR code promos
* Sponsored contributions

repository: ChristianKrebel/party-popper

branch_name: refs/heads/master

repo_name: ChristianKrebel/party-popper


text:
# Panoptes Parts List

| Item | Quantity | Vendor & Part | Approx. Price | Notes
|---|:---:|---|---|---
| __Camera Box__
| Camera: Canon SL1 DSLR  | 2  | Amazon B00BW6LXHA | $399 | [Jun 03, 2015] check also used cameras, at ~$290
| Lens: Rokinon 85M-C 85mm f/1.4 | 2 | Amazon B0025EWXEU | $269 | [Jun 03, 2015]
| SD Card: | 2 | | $ | get 4GB or more
| Camera Power Supply Canon ACK-EL15 or equivalent  | 2 | Amazon B00F5VMIQS | $15.75 | [Jun 03, 2015]
| Camera Enclosure: Bud Industries NBF-32318 |  1 | Amazon B005UPBOXW | $58.95 | [Jun 03, 2015]
| Aluminum Plates 0.5" x 3" x 12" | 3 | eBay | $8.59 | [Jun 03, 2015] ebay temco ($85.58 for qty=10). If not available on eBay, try www.speedymetals.com (likely to be more expensive + shipping)
| Vixen Dovetail Rail | 1 | OPT #OR-7383 (or OPT #SV-TP10) | $21-40 (2015/03) | any ~8" long Vixen style rail will work
| USB Hub | 1 | Amazon B003M0NURK | $6.75 | [Jun 03, 2015]
| Mini right angle USB cable | 2 | Amazon B004W8EIMW | $4.19 | [Jun 03, 2015] Right angle connected required to fit in tight space
|
| __Mount__
| Mount: iOptron iEQ30 Pro | 1 | OPT #IO-3000E | $1398 (2015/03)
|
| __Custom Pier__ | | | | __The pier is optional, you can use the included tripod instead__
| Aluminum 8"x8" x 3/4" | 1 | eBay | $22.15 | [Jun 03, 2015] eBay seller m6061dude, otherwise try onlinemetals (likely to be more expensive + shipping)
| Aluminum 12"x12" x 3/4" | 1 | eBay | $46 | [Jun 03, 2015] eBay seller metalremnantsinc, otherwise try speedymetals (likely to be more expensive + shipping)
| Webcam mounting bracket | 2 | Amazon B003XJ0MQM | $6.58 | [Jun 03, 2015]
| Pier post beams, 500mm long extrusion | 2 | Misumi HFS8-80160-500-TPW | $84.75 | [Jun 05, 2015]
| Pier post side beam for webcm | 1 | Misumi HFS8-4080-400 | $13.20 | [Jun 05, 2015]
| end caps | 1 | Misumi HFC8-4080-S | $3.00 | [Jun 05, 2015]
|
| __Electronics Box__
| Electronics Enclosure: Pelican 1560 | 1 | Amazon B000ALVE2M | $164.95 | Pick light color (white, silver, grey)
| Perforated Sheet 12"x24"| 1 | Amazon B000ILJZWA | $29.67 | [Jun 03, 2015]
| PVC bar, 1"x1" 60" long | 1 | Amazon B0013HJCJ4 | $25.77 | [Jun 03, 2015]
| Power Supply | 1 | PowerStream PST-SP12AL | $98 (2015/03) | http://www.powerstream.com/12V-backup.htm
| 12V Battery | 1 | Amazon B00K8I758O | $27.99 | [Jun 03, 2015] Battery should have >12Ah capacity, size should be ~6"x4"x4".
| Computer: Intel NUC | 1 | Amazon NUC5i3RYK (or NUC5i5RYK) | $299 | [Jun 03, 2015] 5th genration upgrade possible
| 4 GB RAM for NUC | 1 | Amazon B005MWQ6WC | $27.99 | [Jun 03, 2015] use any compatible RAM, 4 GB or more.
| 128 GB SSD for NUC | 1 | Amazon B00KLTPUPA | $64.99 | [Jun 03, 2015] use any compatible SSD, 64 GB or more
| External Hard Drive | 2 | | $ |
| USB to Serial Adapter | | | | |
| USB Cables | | | |
| USB Hub | | | |
| 80mm ball bearing fan | 1 | Amazon B0009JZSKO | $4.95 | [Jun 03, 2015]
|
| __Bolts__
| M6 Bolts | | | | |
| 1/4-20 Bolts | | | | |
|
| __Electronics__ (incomplete list)
| Arduino Micro | 2 | Adafruit #1086 | $25 (2015/03) |
| Temperature Sensor: DS18B20 | 5 | Adafruit #374 | $4 (2015/03) |
| Humidity Sensor: DHT22 or AM2302 | 2 | Adafruit #393 | $15 (2015/03) |
| Orientation Sensor: MMA8451 | 1 | Adafruit #2019 | $8 (2015/03) |
| 9V DC Regulator: |
| 5V DC Regulator: |
| Relay: |
| Relay: |
|
| __Weather Station__
| AAG Cloud Sensor | 1 | OPT #TT-AAG2 | $495 (2015/03) |
| AAG Anemometer | 1 | OPT #TT-ANEMO4403 | $149 (2015/03) |

## Tools / Misc

* Power hand drill or drill press
	* Hole Saw
	* Hole Saw Drill
* Label maker

path: /Panoptes Parts List.md

filename: Panoptes Parts List.md


text:
# Django Natural Keys

Enhanced support for [natural keys] in Django and [Django REST Framework].  Extracted from [wq.db] for general use.

*Django Natural Keys* provides a number of useful model methods (e.g. `get_or_create_by_natural_key()`) that speed up working with natural keys in Django.  The module also provides a couple of serializer classes that streamline creating REST API support for models with natural keys.

[![Latest PyPI Release](https://img.shields.io/pypi/v/natural-keys.svg)](https://pypi.org/project/natural-keys/)
[![Release Notes](https://img.shields.io/github/release/wq/django-natural-keys.svg)](https://github.com/wq/django-natural-keys/releases)
[![License](https://img.shields.io/pypi/l/natural-keys.svg)](https://github.com/wq/django-natural-keys/blob/main/LICENSE)
[![GitHub Stars](https://img.shields.io/github/stars/wq/django-natural-keys.svg)](https://github.com/wq/django-natural-keys/stargazers)
[![GitHub Forks](https://img.shields.io/github/forks/wq/django-natural-keys.svg)](https://github.com/wq/django-natural-keys/network)
[![GitHub Issues](https://img.shields.io/github/issues/wq/django-natural-keys.svg)](https://github.com/wq/django-natural-keys/issues)

[![Tests](https://github.com/wq/django-natural-keys/actions/workflows/test.yml/badge.svg)](https://github.com/wq/django-natural-keys/actions/workflows/test.yml)
[![Python Support](https://img.shields.io/pypi/pyversions/natural-keys.svg)](https://pypi.org/project/natural-keys/)
[![Django Support](https://img.shields.io/pypi/djversions/natural-keys.svg)](https://pypi.org/project/natural-keys/)

## Usage

*Django Natural Keys* is available via PyPI:

```bash
# Recommended: create virtual environment
# python3 -m venv venv
# . venv/bin/activate
pip install natural-keys
```

### Model API

To use [natural keys] in vanilla Django, you need to define a `natural_key()` method on your Model class and a `get_natural_key()` method on the Manager class.  With *Django Natural Keys*, you can instead extend `NaturalKeyModel` and define one of the following:

 * A [`UniqueConstraint`][UniqueConstraint] in `Meta.constraints` (recommended),
 * A tuple in [`Meta.unique_together`][unique_together], or
 * A [model field][unique] (other than `AutoField`) with `unique=True`

The first unique constraint found will be treated as the natural key for the model, and all of the necessary functions for working with natural keys will automatically work.

```python
from natural_keys import NaturalKeyModel

class Event(NaturalKeyModel):
    name = models.CharField(max_length=255)
    date = models.DateField()
    class Meta:
        constraints = [
            models.UniqueConstraint(
                fields=('name', 'date'),
                name='event_natural_key',
            )
        ]

class Note(models.Model):
    event = models.ForeignKey(Event)
    note = models.TextField()
```
or
```python
from natural_keys import NaturalKeyModel

class Event(NaturalKeyModel):
    name = models.CharField(unique=True)
```

The following methods will then be available on your Model and its Manager:

```python
# Default Django methods
instance = Event.objects.get_by_natural_key('ABC123', date(2016, 1, 1))
instance.natural_key == ('ABC123', date(2016, 1, 1))

# get_or_create + natural keys
instance, is_new = Event.objects.get_or_create_by_natural_key('ABC123', date(2016, 1, 1))

# Like get_or_create_by_natural_key, but discards is_new
# Useful for quick lookup/creation when you don't care whether the object exists already
instance = Event.objects.find('ABC123', date(2016, 1, 1))
note = Note.objects.create(
     event=Event.objects.find('ABC123', date(2016, 1, 1)),
     note="This is a note"
)
instance == note.event

# Inspect natural key fields on a model without instantiating it
Event.get_natural_key_fields() == ('name', 'date')
```

#### Nested Natural Keys
One key feature of *Django Natural Keys* is that it will automatically traverse `ForeignKey`s to related models (which should also be `NaturalKeyModel` classes).  This makes it possible to define complex, arbitrarily nested natural keys with minimal effort.

```python
class Place(NaturalKeyModel):
    name = models.CharField(max_length=255, unique=True)

class Event(NaturalKeyModel):
    place = models.ForeignKey(Place)
    date = models.DateField()
    class Meta:
        constraints = [
            models.UniqueConstraint(
                fields=('place', 'date'),
                name='event_natural_key',
            )
        ]
```

```python
Event.get_natural_key_fields() == ('place__name', 'date')
instance = Event.find('ABC123', date(2016, 1, 1))
instance.place.name == 'ABC123'
```

### REST Framework Support
*Django Natural Keys* provides several integrations with [Django REST Framework], primarily through custom Serializer classes.  In most cases, you will want to use either:
 * `NaturalKeyModelSerializer`, or
 * The `natural_key_slug` pseudo-field (see below)

If you have only a single model with a single char field for its natural key, you probably do not need to use either of these integrations.  In your view, you can just use Django REST Framework's built in `lookup_field` to point directly to your natural key.

#### `NaturalKeyModelSerializer`
`NaturalKeyModelSerializer` facilitates handling complex natural keys in your rest API.  It can be used with a `NaturalKeyModel`, or (more commonly) a model that has a foreign key to a `NaturalKeyModel` but is not a `NaturalKeyModel` itself.  (One concrete example of this is the [vera.Report] model, which has a ForeignKey to [vera.Event], which is a `NaturalKeyModel`).

`NaturalKeyModelSerializer` extends DRF's [ModelSerializer], but uses `NaturalKeySerializer` for each foreign key that points to a `NaturalKeyModel`.  When `update()` or `create()`ing the primary model, the nested `NaturalKeySerializer`s will automatically create instances of referenced models if they do not exist already (via the `find()` method described above).  Note that `NaturalKeyModelSerializer` does not override DRF's default behavior for other fields, whether or not they form part of the primary model's natural key.

`NaturalKeySerializer` can technically be used as a top level serializer, though this is not recommended.  `NaturalKeySerializer` is designed for dealing with nested natural keys and does not support updates or non-natural key fields.  Even when used together with `NaturalKeyModelSerializer`, `NaturalKeySerializer` never updates an existing related model instance.  Instead, it will repoint the foreign key to another (potentially new) instance of the related model.  It may help to think of `NaturalKeySerializer` as a special [RelatedField] class rather than as a `Serializer` per se.

You can use `NaturalKeyModelSerializer` with [Django REST Framework] and/or [wq.db] just like any other serializer:
```python
# Django REST Framework usage example
from rest_framework import viewsets
from rest_framework import routers
from natural_keys import NaturalKeyModelSerializer
from .models import Event, Note

class EventSerializer(NaturalKeyModelSerializer):
    class Meta:
        model = Event

class NoteSerializer(NaturalKeyModelSerializer):
    class Meta:
        model = Note

class EventViewSet(viewsets.ModelViewSet):
    queryset = Event.objects.all()
    serializer_class = EventSerializer

class NoteViewSet(viewsets.ModelViewSet):
    queryset = Note.objects.all()
    serializer_class = NoteSerializer

router = routers.DefaultRouter()
router.register(r'events', EventViewSet)
router.register(r'notes', NoteViewSet)

# wq.db usage example
from wq.db import rest
from natural_keys import NaturalKeyModelSerializer
from .models import Event, Note

rest.router.register_model(Note, serializer=NaturalKeyModelSerializer)
rest.router.register_model(Event, serializer=NaturalKeyModelSerializer)
```

Once this is set up, you can use your REST API to create and view your `NaturalKeyModel` instances and related data.  To facilitate integration with regular HTML Forms, *Django Natural Keys* is integrated with the [HTML JSON Forms] package, which supports nested keys via an array naming convention, as the examples below demonstrate.

```html
<form action="/events/" method="post">
  <input name="place[name]">
  <input type="date" name="date">
</form>
```
```js
// /events.json
[
    {
        "id": 123,
        "place": {"name": "ABC123"},
        "date": "2016-01-01"
    }
]
```
```html
<form action="/notes/" method="post">
  <input name="event[place][name]">
  <input type="date" name="event[date]">
  <textarea name="note"></textarea>
</form>
```
```js
// /notes.json
[
    {
        "id": 12345,
        "event": {
            "place": {"name": "ABC123"},
            "date": "2016-01-01"
        },
        "note": "This is a note"
    }
]
```

### Natural Key Slugs
As an alternative to using `NaturalKeyModelSerializer` / `NaturalKeySerializer`, you can also use a single slug-like field for lookup and serialization.  `NaturalKeyModel` (and its associated queryset) defines a pseudo-field, `natural_key_slug`, for this purpose.

```python
class Place(NaturalKeyModel):
    name = models.CharField(max_length=255, unique=True)

class Room(NaturalKeyModel)
    place = models.ForeignKey(Place, models.ON_DELETE)
    name = models.CharField(max_length=255)

    class Meta:
        unique_together = (('place', 'name'),)
```
```python
room = Room.objects.find("ABC123", "MainHall")
assert(room.natural_key_slug == "ABC123-MainHall")
assert(room == Room.objects.get(natural_key_slug="ABC123-MainHall"))
```

You can expose this functionality in your REST API to expose natural keys instead of database-generated ids.  To do this, you will likely want to do the following:

 1. Create a regular serializer with `id = serializers.ReadOnlyField(source='natural_key_slug')`
 2. Set `lookup_field = 'natural_key_slug'` on your `ModelViewSet` (or similar generic class) and update the URL registration accordingly
 3. Ensure foreign keys on any related models are serialized with `serializers.SlugRelatedField(slug_field='natural_key_slug')`

In [wq.db], all three of the above can be achieved by setting the `"lookup"` attribute when registering with the [router]:

```python
# myapp/rest.py
from wq.db import rest
from .models import Room

rest.router.register_model(
    Room,
    fields='__all__',
    lookup='natural_key_slug',
)
```

Note that the `natural_key_slug` may not behave as expected if any of the component values contain the delimiter character (`-` by default).  To mitigate this, you can set `natural_key_separator` on the model class to another character.

[natural keys]: https://docs.djangoproject.com/en/4.2/topics/serialization/#natural-keys
[UniqueConstraint]: https://docs.djangoproject.com/en/4.2/ref/models/constraints/#uniqueconstraint
[unique_together]: https://docs.djangoproject.com/en/4.2/ref/models/options/#unique-together
[unique]: https://docs.djangoproject.com/en/4.2/ref/models/fields/#unique

[wq.db]: https://wq.io/wq.db/
[Django REST Framework]: http://www.django-rest-framework.org/
[vera.Report]:https://github.com/powered-by-wq/vera#report
[vera.Event]: https://github.com/powered-by-wq/vera#event
[ModelSerializer]: https://www.django-rest-framework.org/api-guide/serializers/#modelserializer
[RelatedField]: https://www.django-rest-framework.org/api-guide/relations/
[HTML JSON Forms]: https://github.com/wq/html-json-forms
[router]: https://wq.io/wq.db/router

repository: wq/django-natural-keys

gha_language: Python

gha_license_id: MIT

repo_name: wq/django-natural-keys


text:
## ObjectMerger
Originally published: 2004-03-04 20:53:04
Last updated: 2004-03-05 15:44:56
Author: Alejandro David Weil

The ObjectMerger class dynamically merges two given objects, making one a subclass of the other. The input elements could either be class instances or simple types, making this class particularly useful to derive native classes (for instance, cStringIO).
The resulting ObjectMerger instance acts as a proxy to the new type, allowing callers to work with it in the same way they would work with any other statically derived type.


text:
# TCL Code Reviewer (alpha)

A basic implementation of a code reviewer for TCL.

Currently runs a set of regular expressions to check for some common (but sometimes hard to spot) errors.

## Unit testing

```
cd tclrev
tclsh test/runner.tcl
```

## Running

A usage message:

```
$ cd tclrev
$ tclsh tcl/main.tcl

Usage:
tclsh tcl/main.tcl
  args:
    --dir
         Path to the directory to check
    --level - Optional - default value: INFO
         Log Level: ERROR|WARN|INFO
    -s
         Scan symlinked directories
```

## Example

```
$ cd tclrev
$ tclsh tcl/main.tcl --dir test_end2end/ --level WARN
WARN :: ---------------------------------
WARN :: test_end2end/expr_test.tcl:12
WARN :: expr's expression needs to be enclosed in {}
WARN :: expr 1 + 1
WARN ::
ERROR :: ---------------------------------
ERROR :: test_end2end/llength_test.tcl:16
ERROR :: The 1st llength arg must be a variable, command or list
ERROR :: llength lvar
ERROR ::
ERROR :: ---------------------------------
ERROR :: test_end2end/lsearch_test.tcl:18
ERROR :: The 1st lsearch arg must be a variable, command or list
ERROR :: lsearch lvar a
ERROR ::
ERROR :: ---------------------------------
ERROR :: test_end2end/unbalanced_braces.tcl:
ERROR :: Unbalanced braces
ERROR ::
```

## Valid commands checks

### RegEx Checks

| Check | Description |
| ---   | ---         |
| expr     | Check for curly brackets to avoid possible double execution. |
| llength  | The first argument must be a variable, command or list. |
| lsort    | The first argument must be a variable, command or list. |
| lsearch  | The first argument must be a variable, command or list. |
| lreverse | The first argument must be a variable, command or list. |
| lreplace | The first argument must be a variable, command or list. |
| lrange   | The first argument must be a variable, command or list. |
| lindex   | The first argument must be a variable, command or list. |

### Other Checks

| Check | Description |
| ---   | ---         |
| Brace check | Check balanced braces|

# Future (possible) functionality

| Check | Description |
| ---   | ---         |
| (TODO) Multiline | Commands split to multiple lines to contain "\" at the end of each line.|
| (TODO) Junit style reports | Could easily be integrated into CI tools|


text:
# Django REST Framework Related Object Field

A lightweight package that allows for custom handling on `PrimaryKeyRelatedField` in serializers.
The default behaviour of the mixin is to allow the normal behaviour of the `PrimaryKeyRelatedField` for
writes (i.e. require the PK as input data for POST, PUT and PATCH) and to render the related object using
the given serializer for GET requests. If no serializer is passed, defaults to the normal behaviour.

Serialization (i.e. object to data) works in both ways of the relationship, that is you can
simply use the mixin just like in the snippet below. However, for deserialization (i.e. data
to object), this only works (it is only tested) for many to one relationship in this exact direction.
That is, if you have an `Author` and a `Book`, where an author can have many books, then
you will only be able to create/edit the books by passing them the author ID, but not vice-versa.

## Code example

```python
from rest_framework import serializers

from drf_related_object_field.mixins import RelatedObjectFieldMixin

class RelatedObjectSerializer(serializers.ModelSerializer):
    class Meta:
        model = MyRelatedModel
        fields = "__all__"

class MySerializer(RelatedObjectFieldMixin, serializers.ModelSerializer):
    class Meta:
        model = MyModel
        fields = ("id", "name", "my_related_object")
        extra_kwargs = {
            "my_related_object": {
                "serializer_class": RelatedObjectSerializer,
            },
        }

```

repository: linnify/drf-related-object-field

repo_name: linnify/drf-related-object-field


text:
Speed comparison of the three DI libraries Katana, [Koin](https://github.com/Ekito/koin) and [Kodein](https://github.com/Kodein-Framework/Kodein-DI).

Also see this independent [comparison](https://github.com/Sloy/android-dependency-injection-performance).

## Test setup

Please have a look at the source code. The test is divided into the two blocks *setup* and *execution*. *Setup* tests
how fast the test subject is in setting up the dependency injection (creating modules, bindings, etc.) and *execution*
tests the actual injection. The test collects the average and median time in nanoseconds of 1,000,000 iterations of
each block.

### Library versions

| Library | Version |
| ------- | ------- |
| Katana  | 1.2.0   |
| Koin    | 1.0.2   |
| Kodein  | 6.0.1   |

For fairness towards Kodein the [erased](http://kodein.org/Kodein-DI/?5.2/getting-started#_flavour) version of Kodein
was used for this comparison. It should be faster since it doesn't use reflection.

## Test environment

The test has been performed on a 2017 MacBook Pro with a 3,1 GHz Intel Core i7 CPU, 16 GB RAM, macOS Mojave 10.14 and
Java 1.8.0_181-b13.

## Results

All times in nanoseconds.

| Library | Setup (average) | Setup (median) | Execution (average) | Execution (median) |
| ------- | ---------------:| --------------:| -------------------:| ------------------:|
| Katana  |     1026.766894 |          766.0 |          355.977582 |              276.0 |
| Kodein  |     1621.426234 |         1149.0 |          970.987781 |              729.0 |
| Koin    |     5155.923505 |         3968.0 |         7035.575007 |             5653.0 |

## How to build and run comparison

From the root folder of the project run:

```
./gradlew :speed-comparison:build
java -jar ./speed-comparison/build/libs/speed-comparison-fat-1.2.0.jar
```

repository: Hazer/katana

repo_name: Hazer/katana


text:
# Portable SIMD Project Group

![project group status: active](https://img.shields.io/badge/status-active-brightgreen.svg)

Welcome to the repository for the Portable SIMD Project Group! This is the
repository we use to organise our work. Please refer to our [charter] for
more information on our goals and current scope.

[charter]: ./CHARTER.md

## Current Status

We're currently working on an initial `std::simd` implementation over in the [stdsimd] repo.

## How Can I Get Involved?

[You can find a list of the current members available
on `rust-lang/team`.][team-toml]

The best place to start is looking at [open issues in stdsimd][stdsimd-issues].

We also participate on [Zulip][chat-link], feel free to introduce
yourself over there and ask us any questions you have.

Group meetings happen every week via [Zulip][chat-link].
You can find them on the [Libs team calendar][calendar]!

[open issues]: ../../issues
[chat-link]: https://rust-lang.zulipchat.com/#narrow/stream/257879-project-portable-simd
[team-toml]: https://github.com/rust-lang/team/blob/master/teams/project-portable-simd.toml
[calendar]<EMAIL_ADDRESS>[stdsimd]: https://github.com/rust-lang/stdsimd
[stdsimd-issues]: https://github.com/rust-lang/stdsimd/issues


text:
SlmQueue
========

[![Latest Stable Version](https://poser.pugx.org/slm/queue/v/stable.png)](https://packagist.org/packages/slm/queue)

SlmQueue is a job queue abstraction layer for Laminas (formerly Zend Framework) and Mezzio (formerly Zend Expressive) applications. It supports various job queue systems and
makes your application independent from the underlying system you use. The currently supported systems have each their
own adapter library:

* [Doctrine ORM](https://github.com/Webador/SlmQueueDoctrine)
* [RabbitMQ](https://github.com/rnd-cosoft/slm-queue-rabbitmq)
* [Amazon SQS](https://github.com/Webador/SlmQueueSqs) (outdated, [maintainers wanted](https://github.com/Webador/SlmQueueSqs/issues/58))

When to use
-----------

A job queue helps to offload long or memory-intensive processes from the HTTP requests clients sent to the Laminas
application. This will make your response times shorter and your visitors happier. There are many use cases
for asynchronous jobs and a few examples are:

1. Send an email
2. Create a PDF file
3. Connect to a third party server over HTTP

In all cases you want to serve the response as soon as possible to your visitor, without letting them wait for this
long process. SlmQueue enables you to implement a job queue system very easily within your existing application.

Installation
------------

SlmQueue works with [Composer](http://getcomposer.org). Make sure you have the composer.phar downloaded and you have a
`composer.json` file at the root of your project. To install it, add the following line into your `composer.json` file:

```json
"require": {
    "slm/queue": "^3.0"
}
```

After installation of the package, you need to complete the following steps to use SlmQueue:

 1. Enable the module by adding `SlmQueue` in your `application.config.php` file.
 2. Copy the `slm_queue.global.php.dist` (you can find this file in the `config` folder of SlmQueue) into
your `config/autoload` folder and apply any setting you want.

NB. SlmQueue is a skeleton and therefore useless by itself. Enable an adapter to give you the implementation details
you need to push jobs into the queue. Install one of the available adapters ([SlmQueueDoctrine](https://github.com/Webador/SlmQueueDoctrine), [SlmQueueRabbitMq](https://github.com/rnd-cosoft/slm-queue-rabbitmq), or [SlmQueueSqs](https://github.com/Webador/SlmQueueSqs)).

Requirements
------------
* PHP >= 7.4
* [laminas-servicemanager >= 3.3.1](https://github.com/laminas/laminas-servicemanager)

Code samples
------------
Below are a few snippets which show the power of SlmQueue in your application. The full documentation is available in
[docs/](/docs) directory.

A sample job to send an email with php's `mail()` might look like this:

```php
namespace MyModule\Job;

use SlmQueue\Job\AbstractJob;

class EmailJob extends AbstractJob
{
    public static function create(string $to, string $subject, string $message): self
    {
        // This will bypass the constructor, and thus load a job without
        // having to load the dependencies.
        $job = self::createEmptyJob([
            'subject' => $subject,
            'to' => $to,
            'message' => $message,
        ]);

        // Add some metadata, so we see what is going on.
        $job->setMetadata('to', $to);

        return $job;
    }

    private SomeMailService $mailService;

    public function __construct(SomeMailService $mailService)
    {
        $this->mailService = $mailService;
    }

    public function execute()
    {
        $payload = $this->getContent();

        $to      = $payload['to'];
        $subject = $payload['subject'];
        $message = $payload['message'];

        $this->mailService->send($to, $subject, $message);
    }
}
```

If you want to inject this job into a queue, you can do this for instance in your controller:

```php
namespace MyModule\Controller;

use MyModule\Job\Email as EmailJob;
use SlmQueue\Queue\QueueInterface;
use Laminas\Mvc\Controller\AbstractActionController;

class MyController extends AbstractActionController
{
    protected $queue;

    public function __construct(QueueInterface $queue)
    {
        $this->queue = $queue;
    }

    public function fooAction()
    {
        // Do some work

        $this->queue->push(
<EMAIL_ADDRESS>'Just hi', 'Hi, I want to say hi!'),
            ['delay' => 60]
        );
    }
}
```

Now the above code lets you insert jobs in a queue, but then you need to spin up a worker which can process these jobs.

SlmQueue integrates with [`laminas-cli`](https://github.com/laminas/laminas-servicemanager) for command line usage. You can start up a worker for queue "default" with the following command:

```sh
$ vendor/bin/laminas slm-queue:start default
```

Contributing
------------

SlmQueue is developed by various fanatic Laminas users. The code is written to be as generic as possible for
Laminas applications. If you want to contribute to SlmQueue, fork this repository and start hacking!

Any bugs can be reported as an [issue](https://github.com/Webador/SlmQueue/issues) at GitHub. If you want to
contribute, please be aware of the following guidelines:

 1. Fork the project to your own repository
 2. Use branches to work on your own part
 3. Create a Pull Request at the canonical SlmQueue repository
 4. Make sure to cover changes with the right amount of unit tests
 5. If you add a new feature, please work on some documentation as well

For long-term contributors, push access to this repository is granted.

Who to thank?
-------------

[Jurian Sluiman](https://github.com/juriansluiman) and [Michaël Gallego](https://github.com/bakura10) did the initial work on creating this repo, and maintained it for a long time.

Currently it is maintained by:

* [Bas Kamer](https://github.com/basz)
* [Roel van Duijnhoven](https://github.com/roelvanduijnhoven)

repository: Webador/SlmQueue

gha_language: PHP

gha_license_id: NOASSERTION

repo_name: Webador/SlmQueue


text:
# Members

## TweenPosition

Interpolates the [Position](#memberPosition) property from its current value
to *endPosition*, for the duration of *time* seconds.

*easingDirection* indicates the timing function to be used, while
*easingStyle* indicates the interpolation function to be used.

*override* indicates whether the tween will override another tween that is
currently running. This only applies to functions that modify the Position.

If *callback* is specified, then it will be called after the tween finishes.
It receives a TweenStatus enum as its only argument. If the tween successfully
finished, then this will be `TweenStatus.Completed`. If it was overridden,
then this will be `TweenStatus.Canceled`.

This function returns whether it was able to begin tweening. If there is
another tweening function currently modifying the Position, and *override* is
false, then this will return false.

If the GuiObject is not the descendant of a [DataModel](DataModel.html), then
this function will throw the following error:

	Can only tween objects in the workspace

## TweenSize

Interpolates the [Size](#memberSize) property from its current value to
*endSize*, for the duration of *time* seconds.

*easingDirection* indicates the timing function to be used, while
*easingStyle* indicates the interpolation function to be used.

*override* indicates whether the tween will override another tween that is
currently running. This only applies to functions that modify the Size.

If *callback* is specified, then it will be called after the tween finishes.
It receives a TweenStatus enum as its only argument. If the tween successfully
finished, then this will be `TweenStatus.Completed`. If it was overridden,
then this will be `TweenStatus.Canceled`.

This function returns whether it was able to begin tweening. If there is
another tweening function currently modifying the Size, and *override* is
false, then this will return false.

If the GuiObject is not the descendant of a [DataModel](DataModel.html), then
this function will throw the following error:

	Can only tween objects in the workspace

## TweenSizeAndPosition

Interpolates both the [Size](#memberSize) and [Position](#memberPosition)
properties from their current values to *endSize* and *endPosition*,
respectively, for the duration of *time* seconds.

*easingDirection* indicates the timing function to be used, while
*easingStyle* indicates the interpolation function to be used.

*override* indicates whether the tween will override another tween that is
currently running. This only applies to functions that modify either Size or
the Position.

If *callback* is specified, then it will be called after the tween finishes.
It receives a TweenStatus enum as its only argument. If the tween successfully
finished, then this will be `TweenStatus.Completed`. If it was overridden,
then this will be `TweenStatus.Canceled`.

This function returns whether it was able to begin tweening. If there is
another tweening function currently modifying the Size or Position, and
*override* is false, then this will return false.

If the GuiObject is not the descendant of a [DataModel](DataModel.html), then
this function will throw the following error:

	Can only tween objects in the workspace

license: Unlicense


text:
# Framer

Framer creates directory structures from YAML files.

## Installation

Add this line to your application's Gemfile:

    gem "framer"

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install framer

## Usage

Framer is designed to take a YAML file and turn it into a directory structure on disk.

First you need to have a YAML file that describes your directory structure:

    # framer.yml
    ---
    :root1:
      :root1_dir1:
        :root1_dir1_sub1: {}
      :root1_dir2: {}
    :root2:
      :root2_dir1: {}
      :root2_dir2:
        :root2_dir2_sub1: {}
        :root2_dir2_sub2: {}

Then you can use either the API to generate the structure:

    Framer.frame "path_to_yaml_file", "path_to_output_dir"

Or you can generate the same structure from the comand line:

    $ framer frame "path_to_yaml_file", "path_to_output_dir"

*NOTE:* You can execute `$ framer frame` without any arguments and Framer will look for a "framer.yml" in the current directory and build the output in the current directory by default.

## Contributing

1. Fork it
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create new Pull Request

repository: andrewhare/framer

repo_name: andrewhare/framer


text:
---
id: 4947
title: Slim Jesus
date: 2021-04-06T18:12:43+00:00
author: Laima
layout: post
guid: https://ukdataservers.com/slim-jesus/
permalink: /04/06/slim-jesus/
---

* some text
{: toc}

## Who is Slim Jesus

Drill rap artist who quickly gained fame for his hit single “Drill Time” and the song’s accompanying music video which earned a lot of hits on the internet during September of 2015. His follow up song was titled “Buck Buck.”

## Prior to Popularity

He began taking rap music seriously earlier in 2015 before the release of “Drill Time,” but had been making music for years prior.

## Random data

He put a disclaimer in the “Drill Time” music video indicating that all illegal materials presented in the video are merely props.

## Family & Everyday Life of Slim Jesus

He is a native of Hamilton, Ohio. Friends of his used to call him Swag Jesus, but it evolved into Slim Jesus.

## People Related With Slim Jesus

One of his rap inspirations is fellow drill rapper Chief Keef.


text:
# Messenger API
An API for creating automatic tasks :
## Features
- Invite someone to a groupchat conversation
- Read or send messages on a specific conversation
- See the unread messages
- Generate a temporary Facebook account

This API was created to implement chatbots in a group conversation of Messenger since this feature has not been implemented yet.

> Just an empty shell for the moment...

![](https://www.shutterbug.com/images/styles/960-wide/public/photo_post/32152/An%20Empty%20Clam%20Shell%20.jpg)

repository: aberrier/messenger-api

repo_name: aberrier/messenger-api


text:
jQuery File Upload ICanHaz/Mustache Template Engine Plugin
===================================================

An IcanHaz/Mustache template engine plugin for the [jQuery File Upload](https://github.com/blueimp/jQuery-File-Upload).

## Dependencies
* [jQuery File Upload](https://github.com/blueimp/jQuery-File-Upload)
  * [jQuery](http://jquery.com)
  * [jQuery UI widget factory](http://wiki.jqueryui.com/w/page/12138135/Widget_factory)
  * [jQuery Iframe Transport plugin](https://github.com/blueimp/jQuery-File-Upload)
* [ICanHas](http://icanhazjs.com) or [Mustache](https://github.com/janl/mustache.js) template Engine
* I18n library
  (e.g. https://github.com/fnando/i18n-js/blob/master/vendor/assets/javascripts/i18n.js )

## Development notes

### How to add vendor scripts as git subtree module?

#### I18n-js
* Add the remote repository

        git remote add -f i18n-js git://github.com/fnando/i18n-js.git

* Merge with --no-commit

        git merge -s ours --no-commit i18n-js/master

* Get module from tree

        git read-tree --prefix=scripts/src/vendor/i18n-js/ -u i18n-j1/master:vendor/assets/javascripts/

* Pulling in changes

        git pull -s subtree i18n-js master

### How to run the buildr compressor/bundler?
* Install buildr: [https://github.com/balupton/buildr.npm](https://github.com/balupton/buildr.npm)

* Run buildr:

        coffee buildr.coffee

## Changelog
* [CHANGELOG.md](https://github.com/meso-unimpressed/jQuery-File-Upload-ICanHaz-Mustache-Template-Engine/blob/master/CHANGELOG.md)

## Todo for Upcoming Releases
* Test with [mustache.js](https://github.com/janl/mustache.js)
* Write a example [sinatra](http://www.sinatrarb.com/) application.
* Write Usage notes.

## Copyright
Copyright 2012, MESO Web Scapes - Mathias Wollin
[http://meso.net](http://meso.net)

## License
Released under the [MIT license](http://www.opensource.org/licenses/MIT).


text:
# Digital First Careers – Explore careers product

- CI -
- master -

The “Explore careers” product provides the digital front end for citizens to self-serve information and advice on careers.  The product enables users to explore options for career goals and make a confident and informed choice of one that suits them.

The product uses the Sitefinity CMS solution at it's core, and uses the add-on model to extend the core Sitefinity functionality to meet the needs of citizens.  Extended functionality is written in C#, using the .NET framework 4.6.2 and ASP.NET MVC 5.  The product is dependant upon a number of Azure platform services, which are pre-requisites for running the solution.  The following section discusses these dependencies in detail, and the configuration changes that are required to use such services.

_**Note**. The “Explore careers” product showcases available apprenticeship vacancies for a given job profile (such as nurse).  Apprenticeship vacancies are selected and imported into “Explore careers” via a separate component, which can be found in the following repository https://github.com/SkillsFundingAgency/dfc-integration-faa._

You can see the public beta of this service at: https://nationalcareers.service.gov.uk.

## List of dependencies

|Item	|Purpose|
|-------|-------|
|Sitefinity |Content management system|
|SQL Azure|SQL database used by Sitefinity CMS|
|REDIS	|Cache - Not needed for single instance, used by Sitefinity in multi-tenant environment.|
|Azure Search|Search engine for searching Job Profiles  |
|Bing spell check	|API used for spell correction of search terms |
|Course finder	|API used to display available courses related to a Job Profile |
|LMI for all|API used to obtain ASHE published salary informaiton for a Job Profile |

## Running Locally
To run this product locally, you will need to configure the list of dependencies, once configured and the configuration files updated, it should be F5 to run and debug locally. The application can be run using IIS Express or full IIS.

## Local Config Files
Once you have cloned the public repo you need to remove the .template part from the configuration file names listed below.

| Location | Repo Filename | Rename to |
|-------|-------|-------|
| DFC.Digital/Service.Cognitive.BingSpellCheck.UnitTests | app.config.template | app.config |
| DFC.Digital/DFC.Digital.AcceptanceTest | App.config.template | App.config |
| DFC.Digital/DFC.Digital.NonUIAcceptanceTest | App.config.template | App.config |
| DFC.Digital/DFC.Digital.Web.Sitefinity/App_Data/Sitefinity/Configuration | AuthenticationConfig.config.template | AuthenticationConfig.config |
| DFC.Digital/DFC.Digital.Web.Sitefinity/App_Data/Sitefinity/Configuration | DataConfig.config.template | DataConfig.config |
| DFC.Digital/DFC.Digital.Web.Sitefinity/App_Data/Sitefinity/Configuration | SearchConfig.config.template | SearchConfig.config |
| DFC.Digital/DFC.Digital.Web.Sitefinity/App_Data/Sitefinity/Configuration | SecurityConfig.config.template | SecurityConfig.config |
| DFC.Digital/DFC.Digital.Web.Sitefinity | web.config.template | web.config |
| DFC.Digital/DFC.Digital.Web.Sitefinity | web.Debug.config.template | web.Debug.config |
| DFC.Digital/DFC.Digital.Web.Sitefinity | web.Release Pro.config.template | web.Release Pro.config |
| DFC.Digital/DFC.Digital.Web.Sitefinity | web.Release.config.template | web.Release Pro.config |

These files contain keys and other configuration that is particular to your local instance of the application.
You will need to set these as detailed in the sections below.configuration configuration

## Assets

CSS, JS, images and fonts used in this site can found in the following repository https://github.com/SkillsFundingAgency/dfc-digital-assets

## Sitefinity

Project - DFC.Digital.Web.Sitefinity

Sitefinity CMS forms the core of this product. It uses database to store all its content, you can use SQL lite or full sql for database, use a connection string with a user who have enough access to create databases for sitefinity create its required database and configure all its components. You also need to obtain a licence to run sitefinity, for more information on installation and troubleshooting please follow instructions from the vendor

‘Installation: Get started with Sitefinity CMS’
https://docs.sitefinity.com/installation

The following configurations needs to be replaced with your values. You may obtain the same from a blank sitefintiy installation.

| Config File   | Key                                       | Token                       | Example value             |
|-------------| ----------------------------------------- |-----------------------      |:----------------|
|DataConfig.config |	connectionString |	\_\_connectionString\_\_	| e.g. "data source=.;UID=sitefinityUser;PWD=sitefinityPWD;initial catalog=sitefinityDB"           |
|ApplicationInsights.config |	InstrumentationKey |	\_\_appInsightsKey\_\_	| It's a GUID in following format "1abc2345-abc3-41g4-96a9-1ab2cd34ef56"             |
|SecurityConfig.config |	relyingParties - key |	\_\_securityRelyingParties\_\_	| "12ABC3DCC1C686346DC40B816ADC126C011E99210BD8A8AE735CD9A54EDF5188"             |
|SecurityConfig.config |	securityTokenIssuers - key |	\_\_securityTokenIssuers\_\_	| "12ABC3DCC1C686346DC40B816ADC126C011E99210BD8A8AE735CD9A54EDF5188"             |
|SecurityConfig.config |	decryptionKey	| \_\_sitefinitySecurityDecryptionKey\_\_	| "0A1B12AB6CB969A878C3F06B438B6491D79A6CAD22A3982F9497A1AE21CE9740"             |
|SecurityConfig.config |	/securityConfig/applicationRoles/role - [XML] |	\_\_sitefinitySecurityRolesSection\_\_	| \<applicationRoles\> section can be replaced              |
|SecurityConfig.config |	validationKey |	\_\_sitefinitySecurityValidationKey\_\_	| "90A36AB52A6E2D6558AA4AB1CFCBFE15AF8EC6A77015DC53E8CCC865E1D75EC0725E8FB8D31EED4F50FE3D5B050FC7E90508E036A9E5C5B84C17B22787285FC1"             |

After restarting of the application our content types should be recreated by the installed AddOns.
Please, be aware that PreSearchFilters AddOn should be installed first as they are used as related data in the main content type JobProfile.

This will prepare the database and get it ready for populating with relevant content.

## SQL/Azure Database

Technically on installing Sitefinity you can choose any of the following Microsoft SQL Server Express, Microsoft SQL Server, Oracle, MySQL

'Configure and start a Sitefinity project'
https://docs.sitefinity.com/configure-and-start-a-project

In reality we would recomend using MS SQL Server for local development and in our case we have used Azure SQL to deploy the database in Azure envirenment.

## REDIS
Redis caching is not used on local development machines. But it is used when our solution is deployed in Azure Load Balanced environment.

## Azure Search

The default search features in this solution use Azure Search as its search engine.
If you prefer you may set up and change the solution to user other search service providers.

In order to use any of the default search features of the application you will need to set up an Azure search service and
change the related configuration keys below.

The search service is configured in the solution in two places.

* The main web application search configuration, this file can be found in the
DFC.Digital\DFC.Digital.Web.Sitefinity folder of the solution.

* It is also used by the acceptance tests in the soultion and these can be configured in the app.config file at
DFC.Digital\DFC.Digital.AcceptanceTest folder.

| Config File   | Key                                       | Token                       | Example value             |
|-------------| ----------------------------------------- |-----------------------      |:----------------:|
|DFC.Digital.Web.Sitefinity\web.config |	DFC.Digital.JobProfileSearchIndex |	\_\_jobProfileSearchIndex\_\_ | jobprofilesIndex-debug |
|DFC.Digital.Web.Sitefinity\web.config |	DFC.Digital.SearchServiceName |	\_\_searchServiceName\_\_	| jobprofile-search|
|DFC.Digital.Web.Sitefinity\web.config |	DFC.Digital.SearchServiceAdminAPIKey |	\_\_searchServiceAdminApiKey\_\_	| 12C371B3C2368D0A5E15C533138C4297 |
|DFC.Digital.AcceptanceTest\App.config |	DFC.Digital.JobProfileSearchIndex |	\_\_jobProfileSearchIndex\_\_ | jobprofilesIndex-debug |
|DFC.Digital.AcceptanceTest\App.config |	DFC.Digital.SearchServiceName |	\_\_searchServiceName\_\_	| jobprofile-search|
|DFC.Digital.AcceptanceTest\App.config |	DFC.Digital.SearchServiceAdminAPIKey |	\_\_searchServiceAdminApiKey\_\_	| 12C371B3C2368D0A5E15C533138C4297 |

DFC.Digital.Web.Sitefinity\web.config

You can set up a free trial search service by following the instructions at this URL
[Azure Search Set Up](https://docs.microsoft.com/en-us/azure/search/search-create-service-portal)

Once you have completed this set up you will have a search service name, this will be part of the
service URL endpoint that you will configured when setting up the service.

* The value for the DFC.Digital.SearchServiceName key which by default is  __searchServiceName__  need to be replaced
with your own search service name.

* A search service API key is also required  the value for DFC.Digital.SearchServiceAdminAPIKey which by default is set to
__searchServiceAdminApiKey__.
This will the the PRIMARY ADMIN KEY for the Azure Search service that you have set up and can be
found under keys in the settings section of your search service portal.

* The final bit of configuration required is to set up the search index name.
Replace  __jobProfileSearchIndex__  with your own index name for job profile in Sitefinity.
In Sitefinity create two identical search indexes one that exactly matches your chosen index name and a second one that is your index name
appended with -debug.
This second index get used when you are running the solution under debug mode.

Both Indexes need to be on the JobProfile content type and you will need to add the  following additional fields for indexing
AlternativeTitle, Overview, SalaryRange, UrlName, JobProfileCategories, JobProfileSpecialism, HiddenAlternativeTitle, TrainingRoutes,
Enablers, EntryQualifications, Interests, PreferredTaskTypes, JobAreas.

Once configuration is complete, trigger a reindex operation from Sitefinity to build the initial indexes in Azure.

## Bing spell check

To aid users with spell checking when using the search option, the system has a "Did you mean" feature to suggest corrections.
This feature makes use of the Bing Spell Check API, which is part of Azure cognitive services.
You can set up a free trial account to use this service at this URL
[Azure Cognitive Services.](https://azure.microsoft.com/en-us/try/cognitive-services/?api=spellcheck-api)

Once you have set up your Spell Check Service you will be able to replace the Bing Spell API configuration key in the system at the following locations.

| Config File   | Key                                       | Token                       | Example value             |
|-------------| ----------------------------------------- |-----------------------      |:----------------:|
|DFC.Digital.Web.Sitefinity\web.config | DFC.Cognitive.BingSpellCheck.ApiKey |	\_\_bingSpellCheckApiKey\_\_ | 6d5102d3104a4308821cbeeb1e57093 |
|DFC.Digital.Service.Cognitive.BingSpellCheck.UnitTests\app.config | DFC.Cognitive.BingSpellCheck.ApiKey |	\_\_bingSpellCheckApiKey\_\_ | 6d5102d3104a4308821cbeeb1e57093 |

## Course finder

When users are viewing Job profile details the service will try and present them with upto two suggestions for related current courses that may exist.
These courses are retrived from the Course Directory Provider Portal provided by the Skills Funding Agency.

#### Course Search Service
Details on using the API and requesting an account can be found at  [Course Search Service](https://opendata.coursedirectoryproviderportal.org.uk/CourseSearchService.svc) and the
document [Course Directory API.](https://coursedirectoryproviderportal.org.uk/Content/Files/Help/Course%20Directory%20API.pdf)

#### NoSQL Database for Course Search Service Audit

The course search service logs requests, responses and failures to a NoSQL database.
You can set up a trial NoSQL database at this URL [Azure Cosmos DB](https://azure.microsoft.com/en-us/services/cosmos-db/?v=17.45a)

Once you have set up the service you will be able the replace the tokens for the configuration keys in the locations below.

| Config File   | Key                                       | Token                       | Example value             |
|-------------| ----------------------------------------- |-----------------------      |:----------------:|
|DFC.Digital.Web.Sitefinity\web.config | DFC.Digital.CourseSearchApiKey |	\_\_courseSearchApiKey\_\_ | 6d5102d3104a4308821cbeeb1e57093 |
|DFC.Digital.Web.Sitefinity\web.config | DFC.Digital.CourseSearchAudit.EndpointUrl |	\_\_cosmosDbEndpointUrl\_\_ | https://coursesearch.Aadit.documents.azure.com:443 |
|DFC.Digital.Web.Sitefinity\web.config | DFC.Digital.CourseSearchAudit.PrimaryKey |	\_\_cosmosDbPrimaryKey\_\_ | fGzzzD3Wd34lkdjfkdf dsjfksjdfkdsfjksdfj354lk45l4543jk2354325lk232DF313j2321jklldgfdgld9FWweeYkhw3Zffz==|

## LMI For All API

LMI For All API -
http://api.lmiforall.org.uk/

The solution  uses the Get /ashe/estimatePayMD API to get an estimation of the median and decile distribution of weekly pay for a job.

| Config File   | Key                                       | Token                       | Example value             |
|-------------| ----------------------------------------- |-----------------------      |:----------------|
|DFC.Digital.Web.Sitefinity\web.config |	DFC.Digital.AsheFeedAccessKey |	\_\_lmiForAllApiAccessKey\_\_	| secret phrase             |
            |

You can obtain an APIAccessKey (the secret phrase)  by contacting 'LMI for All' http://www.lmiforall.org.uk/ (email<EMAIL_ADDRESS>
In our solution we have SalaryCalcluator which calculates yearly salary for starter and experienced levels.
The CMS system can be configured to ignore the data provided by the LMI salary feed and display data which is stored locally in Sitefinity database.

repository: SkillsFundingAgency/dfc-digital

branch_name: refs/heads/dev

gha_language: JavaScript

repo_name: SkillsFundingAgency/dfc-digital


text:
# awesomeness-roadmap
Pathway to awesomeness - some things to learn and use

Coding

* Packaging, versioning, CI
  * Black formatting git hook
  * Automated testing and CI
  * Automated versioning
  * Create and install pip and conda packages
  * Create local package repositories!
  * Docstrings everywhere https://pypi.org/project/interrogate/ https://hynek.me/articles/document-your-tests/
* brassicate and cabbagecutter!
  * How much can anaconda-project take care of?
    * https://github.com/Anaconda-Platform/anaconda-project
    * https://campus.datacamp.com/courses/building-and-distributing-packages-with-conda/anaconda-project?ex=1
  * Upload repos to pypi and conda-forge
  * Include config for:
   * pytest
   * pip
  * Write it all up - docs and blogpost and twitter thread!
* Style and structure
  * ['`if` statements are a code smell']https://us.pycon.org/2020/schedule/presentation/87/
  * Ian Oszvald High Performance Python book
  * Progress bars with tqdm
* Templating with jinja
* SQL
  * Writing better SQL statements in Python https://towardsdatascience.com/advanced-sql-templates-in-python-with-jinjasql-b996eadd761d
  * https://stackoverflow.com/questions/17327043/how-can-i-select-rows-with-most-recent-timestamp-for-each-key-value
* Testing
  * Parametrised tests with Hypothesis
  * Improve pytest skills - need better solution than stashing everything in conftest.py
  * Data tests with e.g. Great Expectations (can pydantic do this job?!)
  * ['Write less and test more with data regression testing']https://us.pycon.org/2020/schedule/presentation/110/
  * Mocking https://changhsinlee.com/pytest-mock/
* Breakpoints and debugging
  * Nina Zakharenko PyCon 2020 talk ['Goodbye `print` - hello, debugger!']https://us.pycon.org/2020/schedule/presentation/158/
* Error handling!
  * https://www.pythonforthelab.com/blog/learning-not-to-handle-exceptions/
  * https://www.programiz.com/python-programming/user-defined-exception
* Frameworks to learn and use
  * Pydantic
  * Prefect
  * Intake
  * Dask
  * FastAPI and Typer
  * PyMC3
  * DoWhy
  * TPOT
  * SKL
* Frontends
  * Citations and cross-refs
  * Voila and ipywidgets
* Privacy-preserving techniques
  * Pseudo-individuals for minimal anonymous datasets
  * PyCon 2020
   * ['Practical privacy-preserving machine learning']https://us.pycon.org/2020/schedule/presentation/130/
   * ['Privacy preserving methods - building secure projects']https://us.pycon.org/2020/schedule/presentation/142/
   *

Agile

* https://docs.microsoft.com/en-us/azure/devops/learn/agile/productive-teams
* Home agile (Asana?) integrated with TFS / Azure Devops
* Create project structure on TFS

repository: ciaranjudge/awesomeness-roadmap

repo_name: ciaranjudge/awesomeness-roadmap


text:
---
title: "List tasks (in a lifecycle workflow)"
description: "Retrieve the details of the built-in tasks in Lifecycle Workflows."
author: "AlexFilipin"
ms.localizationpriority: medium
ms.prod: "governance"
doc_type: apiPageType
---

# List tasks (in a lifecycle workflow)

Namespace: microsoft.graph.identityGovernance

> [!IMPORTANT]
> APIs under the `/beta` version in Microsoft Graph are subject to change. Use of these APIs in production applications is not supported. To determine whether an API is available in v1.0, use the **Version** selector.

Retrieve the details of the built-in tasks in Lifecycle Workflows.

## Permissions

One of the following permissions is required to call this API. To learn more, including how to choose permissions, see [Permissions](/graph/permissions-reference).

|Permission type|Permissions (from least to most privileged)|
|:---|:---|
|Delegated (work or school account)|LifecycleWorkflows.Read.All, LifecycleWorkflows.ReadWrite.All|
|Delegated (personal Microsoft account)|Not supported.|
|Application|LifecycleWorkflows.Read.All, LifecycleWorkflows.ReadWrite.All|

For delegated scenarios, the admin needs one of the following [Azure AD roles](/azure/active-directory/users-groups-roles/directory-assign-admin-roles#available-roles):

- Global administrator
- Global reader
- Lifecycle workflows administrator

## HTTP request

<!-- {
  "blockType": "ignored"
}
-->
``` http
GET /identityGovernance/lifecycleWorkflows/workflow/{workflowId}/tasks
```

## Optional query parameters

This method supports the `$search`, `$orderBy`, and `$filter` OData query parameters to help customize the response. For general information, see [OData query parameters](/graph/query-parameters).

## Request headers

|Name|Description|
|:---|:---|
|Authorization|Bearer {token}. Required.|

## Request body

Do not supply a request body for this method.

## Response

If successful, this method returns a `200 OK` response code and a collection of [microsoft.graph.identityGovernance.task](../resources/identitygovernance-task.md) objects in the response body.

## Examples

### Request

The following is an example of a request.
<!-- {
  "blockType": "request",
  "name": "lifecycleworkflows_list_task"
}
-->
``` http
GET https://graph.microsoft.com/beta/identityGovernance/lifecycleWorkflows/workflow/156ce798-1eb6-4e0a-8515-e79f54d04390/tasks
```

### Response

The following is an example of the response
>**Note:** The response object shown here might be shortened for readability.
<!-- {
  "blockType": "response",
  "truncated": true,
<EMAIL_ADDRESS>"Collection(microsoft.graph.identityGovernance.task)"
}
-->
``` http
HTTP/1.1 200 OK
Content-Type: application/json

{
<EMAIL_ADDRESS>"https://graph.microsoft.com/beta/$metadata#identityGovernance/lifecycleWorkflows/workflows('156ce798-1eb6-4e0a-8515-e79f54d04390')/tasks",
<EMAIL_ADDRESS>2,
    "value": [
        {
            "category": "joiner,leaver",
            "continueOnError": false,
            "description": "Enable user account in the directory",
            "displayName": "Enable User Account",
            "executionSequence": 1,
            "id": "4d9d41d7-a8e1-4f2f-8c8c-a883bc02e6ee",
            "isEnabled": true,
            "taskDefinitionId": "6fc52c9d-398b-4305-9763-15f42c1676fc",
            "arguments": []
        },
        {
            "category": "joiner",
            "continueOnError": false,
            "description": "Send welcome email to new hire",
            "displayName": "Send Welcome Email",
            "executionSequence": 2,
            "id": "a51a6a57-2ef7-4006-b0ca-285b19d5e1c8",
            "isEnabled": true,
            "taskDefinitionId": "70b29d51-b59a-4773-9280-8841dfd3f2ea",
            "arguments": []
        }
    ]
}
```

repository: microsoftgraph/msgraph-beta-sdk-dotnet

gha_language: C#

repo_name: microsoftgraph/msgraph-beta-sdk-dotnet


text:
# process_exists

process_exists returns a boolean which is true if the given processName (like "firefox")
exists else false

# The function
```nim
proc process_exists*(processName: string): bool =

    let names_seq = process_names(pids())
    for name in names_seq:
        if processName == name:
            return true

    return false
```

repository: johnscillieri/psutil-nim

gha_language: Nim

repo_name: johnscillieri/psutil-nim


text:
---
layout: post
title: Week Six
---

## What did you do this week? ##
This week talked about iterators and dove into some c++ specific concepts like friend methods. Iterators are a lot more complicated than what I first thought, they have a lot of intricacies to them. There was no project to work on so the week went by pretty easily.

## What's in my way? ##
There's an OOP test on Thursday that I need to start studying for. I also have some interviews/hacker rank challenges that I need to finish up this week. It's going to be busy compared to last week.

## What will you do next week ##
Next week I'm going to spend a majority of my time studying for the test. The classes leading up to the test have done a good job of preparing me for the material, I just need to look over everything again. Then at the end of the week after I'm done with everything I'm going down to Dallas for the TX/OU game.

The test should be interesting, I'm curious to see the format/difficulty of the test. It seems like a lot of people are taking this class along with algorithims which seems like a lot of work. I'm pretty happy that I took algorithims last year.

## Tip of the week ##
Take advantage of the week before the test where you have no project due. Don't get complacent because you don't have something that you have to turnin, start studying for the test early. I relaxed the entire last week but now I realize that I probably should have been studying.


text:
# Thompson_Regex [![Build Status](https://travis-ci.org/wallymathieu/Thompson_Regex.svg)](https://travis-ci.org/wallymathieu/Thompson_Regex) [![Build status](https://ci.appveyor.com/api/projects/status/xny5sdoebkrbmmr5/branch/master?svg=true)](https://ci.appveyor.com/project/wallymathieu/thompson-regex/branch/master)

port of https://swtch.com/~rsc/regexp/regexp1.html to f#

## Why

In order to have a regex matcher in f#. This algorithm can be reused for other usages.


text:
# NodeJS, ReactJS, Socket.IO Application

A project for Chat Application using Node.js, Express, Mongoose, REST API, ReactJS, and Socket.IO. Has user signup/login, chat windows, user list for chatting with users, seperate chat windows for every user. Currently limited to one-to-one chats.

**Update**: Also features real time annotations on images.

## Live Demo

## Demo

- Hosted at [Chat Annotate App](https://chat-annotate-app.netlify.app/)
- Sample credentials
    - Email<EMAIL_ADDRESS>    - Password: password1

 - [API Docs](http://<IP_ADDRESS>:5000/v1/docs/)

### Youtube video explaining a demo walkthrough

[Chat app + Image annotations app](https://youtu.be/HM7BmTwUEHs).

## Sample user credentials (for the hosted application)
1. Admin user:
    - Username<EMAIL_ADDRESS>    - Password: password1

2. Non admin user 1:
    - Username<EMAIL_ADDRESS>    - Password: password1

3. Non admin user 2:
    - Username<EMAIL_ADDRESS>    - Password: password1

**Note that admin users are preconfigured. You cant register for an admin account, so try the admin user mentioned above for testing purposes**

## Installation

 - Directions for installation and other information related to backend in [README](./backend/README.md) of `/backend`.
 - Directions for installation and other information related to frontend in [README](./frontend/README.md) of `/frontend`.

## Screenshots

1. Login page
![Login page](https://github.com/Vedant1202/react-nodejs-chat-app/blob/master/screenshots/login-page.png?raw=true)

2. Register page
![Register page](https://github.com/Vedant1202/react-nodejs-chat-app/blob/master/screenshots/register-page.png?raw=true)

3. Home page (default)
![Home page (default)](https://github.com/Vedant1202/react-nodejs-chat-app/blob/master/screenshots/home-blank.png?raw=true)

4. Home page (chat active)
![Home page (chat active)](https://github.com/Vedant1202/react-nodejs-chat-app/blob/master/screenshots/chat-open.png?raw=true)

5. Users list collapsed
![Users list collapsed](https://github.com/Vedant1202/react-nodejs-chat-app/blob/master/screenshots/chat-list-collapsed.png?raw=true)

6. Annotations rooms page
![Annotations rooms page](https://github.com/Vedant1202/react-nodejs-chat-app/blob/master/screenshots/annotations-rooms.png?raw=true)

7. Create new annotations room
![Create new annotations room](https://github.com/Vedant1202/react-nodejs-chat-app/blob/master/screenshots/annotations-rooms-creation.png?raw=true)

8. Drag and Drop page
![Drag and Drop page](https://github.com/Vedant1202/react-nodejs-chat-app/blob/master/screenshots/dragdrop.png?raw=true)

9. Drag and drop new element
![Drag and drop new element](https://github.com/Vedant1202/react-nodejs-chat-app/blob/master/screenshots/dragdrop-new.png?raw=true)

10. Drag and drop delete element
![Drag and drop delete element](https://github.com/Vedant1202/react-nodejs-chat-app/blob/master/screenshots/dragdrop-delete.png?raw=true)

## Flowcharts

1. Real time annotations with web sockets
![Real time annotations with web sockets](https://github.com/Vedant1202/react-nodejs-chat-app/blob/master/flowcharts/GSOC-21-real-time-pathology.png?raw=true)

## Contributing

Contributions are more than welcome! Please check out the [contributing guide](CONTRIBUTING.md).

## License

[MIT](LICENSE)


text:
# tf-k3s-hetzner

Sample implementation of a terraform-generated k3s cluster running on hetzner

*Note*: if you can, always use managed k8s clusters! Digital ocean provide a good offering for this.

*Note*: Terraform is best used with a storage backend for the state, such that teams can cooperate together. This is not
available on hetzner, so ommitted here. Please use DO/AWS/GCP as backends if you intend to use this in prod!

Steps:

Raw cluster:

```sh
# This needs to be set
echo $HCLOUD_TOKEN

cd project
terraform apply
# Say yes when necessary.
# takes 1m30s, Creates:
# 5 servers; 3 master, 2 workers. Quorum over masters happens with etcd. 3 masters provides HA.
# 1 load balancer for access to master.
# 1 private network
# Writes one file to disk with kubernetes creds.

# List all nodes to confirm everything is alive (may take 1-2 minutes)
kubectl --kubeconfig certificate.txt get nodes
```

Monitoring/external storage/cert-manager:

```sh
# This needs to be set
echo $HCLOUD_TOKEN

cd cluster
terraform apply -vars "hcloud_token=$HCLOUD_TOKEN"
# say yes when relevant

# Creates:
# cert-manager for letsencrypt certificates
# prometheus operator
# prometheus x2 for HA
# alertmanager x3 for HA
# grafana for metrics collection (connected to prometheus)
# node-exporter x5 (for each node)
```

### TODO:

- Add autoscaling logic for hcloud
- If a master node goes unhealthy, kill it and start a new one
- prometheus alerts of cluster health
- plug in alertmanager to provide alerts
- determine 0-downtime kubernetes version upgrade path

### Known issues:
- Destruction of project terrafirn can end up stuck because of a hetzner bug in deleting subnetworks.
- Application of cluster terraform can require multiple attempts due to k8s race conditions
- Application of cluster terraform may need imports of certain pre-exisiting items
- There are issues with applying the hcloud-csi drivers. It may be best to kubectl install them instead.


text:
---
title: RDO Havana repositories
date: 2013-07-24 18:25:56
author: pixelbeat
---

There are now 4 separate Havana repositories available on RDO

**Trunk packages for Fedora and EL6 derivatives**

The _current_ trunk package series, generated by http://smokestack.openstack.org/
with maximum lag of 1 hour from the latest trunk commit are available for Fedora
and more recently EL6 based distributions.
Please see the README or browse these repositories at:
http://rdo.fedorapeople.org/openstack/openstack-trunk/

**Standard Havana repositories for Fedora and EL6 derivatives**

Also we now have the more standard release repository for Havana,
which contains the recently released Havana milestone 2 packages.
The best way to interact with this repository is to follow
the RDO quick start guide at: http://rdoproject.org/Quickstart
while just replacing "grizzly" with "havana" in step 1.
This package set can be used with EL6 based distros or Fedora 19.
Fedora 19 contains OpenStack Grizzly packages in the official Fedora repositories,
and RDO makes the next OpenStack version available for test and evaluation.
These repositories can be browsed at:
http://rdo.fedorapeople.org/openstack/openstack-havana/

A caveat to note with the above repositories, is that
the openstack-neutron packages are not yet available.
These will be made available in the coming days.

thanks,
Pádraig.

repository: gbraad/redhat-openstack-website

gha_language: HTML

repo_name: gbraad/redhat-openstack-website


text:
# k-table

**_`k-table` is a part of the `k-table` family of components._**

`k-table` is Vuh's web component for a table's container.

It must only receive instances of `k-table-row` as its children.

<!-- Auto Generated Below -->

----------------------------------------------

*Built with [StencilJS](https://stenciljs.com/)*

repository: jf-gm/vuh-components-test

gha_language: TypeScript

repo_name: jf-gm/vuh-components-test


text:
# <IP_ADDRESS> Expose multiple SOAP services as a single SOAP service using proxy service

## Business use case narrative

![Expose multiple SOAP services as a single SOAP service using proxy service](images/<IP_ADDRESS>-Expose-multiple-SOAP-services-as-a-single-SOAP-service-using-proxy-service.png)

In this scenario, multiple back-end SOAP services are exposed as single SOAP service using proxy service in WSO2 ESB.
WSO2 ESB forwards messages to the relevant back-end service by processing the request. User should create new WSDL
aggregating the operations available in each back-end WSDL and publish it as the description of the new SOAP service.

To develop this scenario, users can use the "Custom proxy" template available in WSO2 Enterprise Integrator Tooling and
writing the mediation logic to route message to relevant back-end service using built-in mediators.

## When to use
This approach can be used when required to expose multiple SOAP services as a single SOAP service for external systems.

## Sample use-case

### Prerequisites

### How to try-out sample use-case

## Supported versions
This is supported in all the EI and ESB versions

## Pre-requisites

## Development guidelines

## REST API (if available)

## Deployment guidelines
Standard way of deploying a proxy service is by packaging the proxy service as a Carbon Application. Please refer
[Creating a Proxy Service](https://docs.wso2.com/display/EI640/Creating+a+Proxy+Service) for instructions.

## Reference
[Creating a Proxy Service](https://docs.wso2.com/display/EI640/Creating+a+Proxy+Service)

## Test cases

|      ID       | Summary |
| ------------- | ------------- |
|  <IP_ADDRESS>.1	| Expose multiple SOAP services as a single SOAP service using proxy service by routing the message based on the soap action without payload transformation|
|  <IP_ADDRESS>.2	| Expose multiple SOAP services as a single SOAP service using proxy service by routing the message based on the soap message|

gha_language: Java


text:
# linear_programming_question_2
The question is come from: 來源：奇點無限股份有限公司-演算法工程師筆試題目

Eight people want to enjoy the party, there are requests:

|Main food	|Sub food1	|Sub food2	|The drinks|
| ----- | ------ | ------ | ------ |
|A|	(Any hamburger)	|Salad|	|	Coca Cola|
|B|	Fried chicken *2	|Smoothie|		| |
|C|	Beef burger|	French fries|	|	Black tea|
|D|	|	French fries *2|	Salad	|Coca Cola|
|E|	(Any hamburger)|	French fries|	Popcorn Chicken| |
|F|	Chicken burger|	Smoothie *2|	|	Sprite|
|G|	(Any Main)|	French fries|	Smoothie|	(Any drink)|
|H|	Fried chicken|	(Any sub food)|	|	Sprite|

Other constrains:
Cannot waste too much food- buy 2 more(contain 2) main foods, 4 more(contain 4) sub foods or 3 more(contain 3) drinks are totally the waste.

The menu is as follow:

|Set|	Price|	Main food	|Sub food	|Drinks|
| ----- | ------ | ------ | ------ | ------ |
|Beef burger set	|150|	Beef burger	|French fries	|Coca Cola|
|Pork burger set	|130|	Pork burger	|Popcorn Chicken|	Sprite|
|Chicken burger set	|140|	Chicken burger	|Smoothie	|Black tea|
|Fried chicken set	|150|	fried chicken *2 |	Salad	|Green tea|
|Party set	|200	|fried chicken *4	|French fries *3、smoothie *3	|Coca Cola *4|

|Main food	|Price	|Sub food	|Price|	Drinks|	Price|
| ----- | ------ | ------ | ------ | ------ | ------ |
|Beef burger|	120|	French fries	|55|	Coca Cola|	30|
|Pork burger|	100|	Popcorn Chicken|	60|	Sprite	|30|
|Chicken burger|	110	|Smoothie|	45	|Black tea	|25|
|Fried chicken|	60	|Salad	|50	|Green tea|	25|

They need minimize the cost and satisfy these requirements. Please use the integer programming to help him solve this problem. Need to write down the function, constraints and the variables.

The following is my solution:

They can buy:

|Set	|Main food	|Sub food	|Drinks|
| ----- | ------ | ------ | ------ |
|Beef burger set*1|	Beef burger*0	|French fries*1|	Coca Cola*0|
|Pork burger set*1|	Pork burger*0	|Popcorn Chicken*0	|Sprite*1|
|Chicken burger set*1|	Chicken burger*1|	Smoothie*1|	Black tea*0|
|Fried chicken set*0|	Fried chicken*0	|Salad*2	|Green tea*0|
|Party set*1| | | |

To satisfy the demand:

|Main food	|Sub food	|Drinks|
| ----- | ------ | ------ |
|Beef burger*1|	French fries*5	|Coca Cola*3|
|Pork burger*1|	Popcorn Chicken*1|	Sprite*2|
|Chicken burger*2|	Smoothie*5|	Black tea*1|
|Fried chicken*4	|Salad*2	|Green tea*0|

Beef burger set 1 *150 + Pork burger set 1*130 + Chicken burger set 1*140 + Party set1 * 200 + Chicken burger 1 *110 + French fries 1 *55 + Smoothie 1 * 45 + Salad 2 * 50 + Sprite 1 * 30
= 150 + 130 + 140 + 200 + 110 + 55 + 45 + 100 + 30
= 960

The cost is 960. And the demand is satisfied with 2 more Coca Cola.


text:
# Blockchain
An implementation of Blockchain technology in Java

# Purpose
The purpose of the project is two fold.

1. I wanted to push myself to learn the Blockchain technology. It has many uses both in the cryptocurrency world and in industries outside of that field.

2. I wanted to learn more about using Git and source control within Atom.

# Important Note
This is a work-in-progress. I will add to this README file as I go.

# Author
James Hare

Email<EMAIL_ADDRESS>
LinkedIn: https://www.linkedin.com/in/jameshareuk

# Things I Learned in This project

repository: JamesHare/Blockchain

repo_name: JamesHare/Blockchain


text:
# Desktop Toast Microsoft.Extensions.Logging Adapter

Currently only works with the Desktop Toast [fork](https://github.com/CHDKUtil/DesktopToast).

## Usage

```C#
public async Task<bool> ShowToastAsync(ILoggerFactory loggerFactory)
{
    var request = new ToastRequest
    {
        ToastTitle = "DesktopToast WPF Sample",
        ToastBody = "This is a toast test.",
        ToastLogoFilePath = string.Format("file:///{0}", Path.GetFullPath("toast128.png")),
        ShortcutFileName = "DesktopToast.Wpf.lnk",
        ShortcutTargetFilePath = Assembly.GetExecutingAssembly().Location,
        AppId = "DesktopToast.Wpf",
    };

    var logger = new LoggerAdapter(loggerFactory);
    var result = await ToastManager.ShowAsync(request, logger: logger);

    return (result == ToastResult.Activated);
}
```

**Note:** The named parameter is required to correctly resolve the overload.

## MIT License

Copyright © 2017 Dmitry Shechtman

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

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

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


text:
![Moments](https://raw.githubusercontent.com/dreamyguy/react-emojis/master/docs/react-emojis-logo-github-full-width.png "Render scalable emojis with proper accessibility markup")

# react-emojis

> :rocket: :hamster: :tada: Render all current emojis with proper accessibility markup, on any size

[![MIT Licence](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/dreamyguy/react-emojis/blob/master/LICENSE)

Use **react-emojis** to output the recommended markup for accessible emojis:

```javascript
<Emoji emoji="woman-dancing"/>
```

...outputs:

```html
<span role="img" aria-label="woman dancing" class="react-emojis" style="line-height: 1;">💃</span>
```

## The emojis :tada: :balloon: :unicorn:

Instead of maintaining a list of _emojis_ on this README, I decided it would be best to create a living github page, that would serve both as a way of showcase the _emojis_, the **Emoji** component and facilitate their use:

https://dreamyguy.github.io/react-emojis/

On this page you can:

- Search for _emojis_
- Copy the _emoji_ to the clipboard by clicking on your choice
- Choose what you'd like to copy to the clipboard:
    - **emoji**: The 'emoji' itself _(this is the default option)_.
    - **markup**: Accessible emoji markup.
    - **reactEmojis**: **Emoji** component markup _(based on "react-emojis" usage)_.
    - **nameUrl**: Emoji name _(the reference used by "react-emojis")_.
    - **name**: Emoji name _(CLDR formatting)_.
    - **code**: Emoji's Unicode.
    - **id**: The emoji's id, as set by unicode.org.

## Line-height

**The emoji will get `line-height: 1` by default**. You can override that behavior by:

- Setting a custom `line-height` to the class `react-emojis`, which the markup output provides out of the box.
- Passing a `lineHeight` _prop_ to the component.

The latter can be done as follows:

```javascript
<Emoji emoji="woman-dancing" lineHeight="inherit"/>
```

This will give the emoji the `line-height` _from its parent_.

> One could also pass any valid value to it, as `1.2`, `20px`, etc. There's no validity check here so make sure you pass a valid value.

## Scaling

**The emoji will inherit the font size set by the parent element**. You can override that behavior by:

- Setting a `font-size` to the class `react-emojis`, which the markup output provides out of the box.
- Passing a `size` _prop_ to the component.

The latter can be done as follows:

```javascript
<Emoji emoji="woman-dancing" size="100"/>
```

This will give the emoji `100px` _**font-size**_.

> I'll be working on passing units to the component, so one can scale the emoji in whichever way one prefers. For convenience, the default unit will remain `px` if no `sizeUnit` is passed as _prop_.

## Origin

The [emoji list](https://github.com/dreamyguy/react-emojis/blob/master/src/app/components/EmojiData.js) is based on [unicode.org](https://unicode.org/emoji/charts/full-emoji-list.html)'s current list of named emojis under "browser" column (as of 2019-05-30).

# Using _react-emojis_ through `npm`

**react-emojis** is also [available as a package on `npm`](https://www.npmjs.com/package/react-emojis) and can be installed as a depedency with:

    npm i react-emojis --save

As with any node module, first you'll have to import it with `require`:

```javascript
var Emoji = require('react-emojis');
```

...but in a modern **React** implementation you'll be using `import`:

```javascript
import Emoji from 'react-emojis';
```

_**A note on size**. With **1719** emoji definitions, this package is by no means small..._

> `react-emojis` only worked properly as a `npm` from version `v1.0.4`. If you're reading this it's no longer a problem. :tada:

# Development

## Getting started

Clone this repo locally. You'll need to have [NodeJS][1] installed. Install all dependencies by running:

    npm i

## Run it locally

To start the app locally, run:

    npm run start

This command fires up the application on port `9900`, making it visible on http://localhost:9900. Because this app is based on [create-react-app][2], the port number should be configured on the [.env](https://github.com/dreamyguy/react-emojis/blob/master/.env#L1) file.

## Building the frontend for Production

When you're ready to build for production, run:

     npm run build

This command compiles all production-optimised resources to a folder called **build**. It's meant to be run remotely, at the environment host, at build time.

## License

[MIT](LICENSE)

# About

**react-emojis** was put together by [Wallace Sidhrée][1]. 👨💻🇳🇴

  [1]: http://sidhree.com/
  [2]: https://facebook.github.io/create-react-app/

repository: dreamyguy/react-emojis

repo_name: dreamyguy/react-emojis


text:
---
layout: default
---

# Recent Research

In order to produce a strong first product, the team has taken the liberty of each producing a scientific research paper in the field of their choice. Feel free to browse below and send feedback through any of our contact pages!

Tom F-L: [Investigating the Immersive Capabilities of VR Control Systems](Is-This-Real-Life.pdf)

Sam L: [Reducing Motion Sickness in VR](Sickeningly-Immersive.pdf)

Alix H: [A look at how Indie developers are addressing co-operative gaming in virtual reality’s isolated environment](Will-you-be-my-Friend.pdf)

More content coming soon!


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

0.7.0
-----

* dropped support for PHP < 7.1

0.6.0
-----

* added compatibility with HTTPlug 2

* dropped the support for HHVM and for PHP < 5.6

* updated the `X-Experience-API-Version` header to default to the latest patch
  version (`1.0.3`)

* allow `2.x` releases of the `php-xapi/model` package too

* allow `3.x` releases of the `php-xapi/model` package for PHP 7.2 compatibility

0.5.0
-----

* **CAUTION**: This release drops support for PHP 5.3 due to the introduced
  dependency on `php-http/httplug` (see below).

* The client now depends on the [HTTPlug library](http://httplug.io/) to
  perform HTTP requests. This means that the package now depends the virtual
  `php-http/client-implementation`. To satisfy this dependency you have to
  pick [an implementation](https://packagist.org/providers/php-http/client-implementation)
  and install it together with `php-xapi/client`.

  For example, if you prefer to use [Guzzle 6](http://docs.guzzlephp.org/en/latest/)
  you would do the following:

  ```bash
  $ composer require --no-update php-http/guzzle6-adapter
  $ composer require php-xapi/client
  ```

* The `setHttpClient()` and `setRequestFactory()` method have been added
  to the `XApiClientBuilderInterface` and must be used to configure the
  `HttpClient` and `RequestFactory` instances you intend to use.

  To use [Guzzle 6](http://docs.guzzlephp.org/en/latest/), for example,
  this will look like this:

  ```php
  use Http\Adapter\Guzzle6\Client;
  use Http\Message\MessageFactory\GuzzleMessageFactory;
  use Xabbuh\XApi\Client\XApiClientBuilder;

  $builder = new XApiClientBuilder();
  $client = $builder->setHttpClient(new Client())
      ->setRequestFactory(new GuzzleMessageFactory())
      ->setBaseUrl('http://example.com/xapi/')
      ->build();
  ```

  You can avoid calling `setHttpClient()` and `setRequestFactory` by installing
  the [HTTP discovery](http://php-http.org/en/latest/discovery.html) package.

* The `xabbuh/oauth1-authentication` package now must be installed if you want
  to use OAuth1 authentication.

* Bumped the required versions of all `php-xapi` packages to the `1.x` release
  series.

* Include the raw attachment content wrapped in a `multipart/mixed` encoded
  request when raw content is part of a statement's attachment.

* Added the possibility to decide whether or not to include attachments when
  requesting statements from an LRS. A second optional `$attachments` argument
  (defaulting to `true`) has been added for this purpose to the `getStatement()`,
  `getVoidedStatement()`, and `getStatements()` methods of the `StatementsApiClient`
  class and the `StatementsApiClientInterface`.

* An optional fifth `$headers` parameter has been added to the `createRequest()`
  method of the `HandlerInterface` and the `Handler` class which allows to pass
  custom headers when performing HTTP requests.

0.4.0
-----

* The `XApiClientBuilder` class now makes use of the `SerializerFactoryInterface`
  introduced in release `0.4.0` of the `php-xapi/serializer` package. By
  default, it will fall back to the `SerializerFactory` implemented provided
  by the `php-xapi/symfony-serializer` to maintain backwards-compatibility
  with the previous release. However, you are now able to inject arbitrary
  implementations of the `SerializerFactoryInterface` into the constructor
  of the `XApiClientBuilder` to use whatever alternative implementation
  (packages providing such an implementation should provide the virtual
  `php-xapi/serializer-implementation` package).

0.3.0
-----

* Do not send authentication headers when no credentials have been configured.

* Fixed treating HTTP methods case insensitive. Rejecting uppercased HTTP
  method names contradicts the HTTP specification. Lowercased method names
  will still be supported to keep backwards compatibility though.

* Fixed creating `XApiClient` instances in an invalid state. The `XApiClientBuilder`
  now throws a `\LogicException` when the `build()` method is called before
  a base URI was configured.

* Removed the `ApiClient` class. The `$requestHandler` and `$version` attributes
  have been moved to the former child classes of the `ApiClient` class and
  their visibility has been changed to `private`.

* The visibility of the `$documentDataSerializer` property of the `ActivityProfileApiClient`,
  `AgentProfileApiClient`, `DocumentApiClient`, and `StateApiClient` classes
  has been changed to `private`.

* Removed the `getRequestHandler()` method from the API classes:

  * `ActivityProfileApiClient::getRequestHandler()`
  * `AgentProfileApiClient::getRequestHandler()`
  * `ApiClient::getRequestHandler()`
  * `DocumentApiClient::getRequestHandler()`
  * `StateApiClient::getRequestHandler()`
  * `StatementsApiClient::getRequestHandler()`

* Removed the `getVersion()` method from the API interfaces:

  * `ActivityProfileApiClientInterface::getVersion()`
  * `AgentProfileApiClientInterface::getVersion()`
  * `StateApiClientInterface::getVersion()`
  * `StatementsApiClientInterface::getVersion()`

* Removed the `getVersion()` method from the API classes:

  * `ActivityProfileApiClient::getVersion()`
  * `AgentProfileApiClient::getVersion()`
  * `ApiClient::getVersion()`
  * `DocumentApiClient::getVersion()`
  * `StateApiClient::getVersion()`
  * `StatementsApiClient::getVersion()`
  * `XApiClient::getVersion()`

* Removed the `getUsername()` and `getPassword()` methods from the `HandlerInterface`
  and the `Handler` class.

* Removed the `getHttpClient()` method from the `Handler` class.

* Removed the `getSerializerRegistry()` method from the `XApiClient` class.

* Made all classes final.

0.2.0
-----

* made the client compatible with version 0.5 of the `php-xapi/model` package

* made the client compatible with version 0.3 of the `php-xapi/serializer` package

0.1.0
-----

First release of an Experience API client based on the Guzzle HTTP library.

This package replaces the `xabbuh/xapi-client` package which is now deprecated
and should no longer be used.

repository: php-xapi/client

repo_name: php-xapi/client