text:
[![Latest Stable Version](https://poser.pugx.org/bentools/etl/v/stable)](https://packagist.org/packages/bentools/etl)
[![License](https://poser.pugx.org/bentools/etl/license)](https://packagist.org/packages/bentools/etl)
[![Build Status](https://img.shields.io/travis/bpolaszek/bentools-etl/master.svg?style=flat-square)](https://travis-ci.org/bpolaszek/bentools-etl)
[![Coverage Status](https://coveralls.io/repos/github/bpolaszek/bentools-etl/badge.svg?branch=master)](https://coveralls.io/github/bpolaszek/bentools-etl?branch=master)
[![Quality Score](https://img.shields.io/scrutinizer/g/bpolaszek/bentools-etl.svg?style=flat-square)](https://scrutinizer-ci.com/g/bpolaszek/bentools-etl)
[![Total Downloads](https://poser.pugx.org/bentools/etl/downloads)](https://packagist.org/packages/bentools/etl)

Okay, so you heard about the [Extract / Transform / Load](https://en.wikipedia.org/wiki/Extract,_transform,_load) pattern and you're looking for a PHP library to do the stuff.

Alright, let's go!

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

```bash
composer require bentools/etl:^3.0@alpha
```

_Warning: version 3.0 is a complete rewrite and a involves important BC breaks. Don't upgrade from `^2.0` unless you know what you're doing!_

Usage
-----

To sum up, you will apply _transformations_ onto an `iterable` of any _things_ in order to _load_ them in some place.

Let's start with a really simple example:

```php
use BenTools\ETL\EtlBuilder;
use BenTools\ETL\Loader\JsonFileLoader;

$data = [
    'foo',
    'bar',
];

$etl = EtlBuilder::init()
    ->loadInto(JsonFileLoader::toFile(__DIR__.'/data.json'))
    ->createEtl();
$etl->process($data);
```

Basically you just loaded the string `["foo","bar"]` into `data.json`. Yay!

Now let's apply a basic uppercase transformation:

```php
use BenTools\ETL\EtlBuilder;
use BenTools\ETL\Loader\JsonFileLoader;

$data = [
    'foo',
    'bar',
];

$etl = EtlBuilder::init()
    ->transformWith(new CallableTransformer('strtoupper'))
    ->loadInto(JsonFileLoader::factory())
    ->createEtl();
$etl->process($data, __DIR__.'/data.json'); // You can also set the output file when processing :-)
```

Didn't you just write the string `["FOO","BAR"]` into `data.json` ? Yes, you did!

Okay, but what if your source data is not an iterable (yet)? It can be a CSV file or a CSV string, for instance. Here's another example:

```php
use BenTools\ETL\EtlBuilder;
use BenTools\ETL\Extractor\CsvExtractor;
use BenTools\ETL\Loader\JsonFileLoader;

$data = <<<CSV
country_code,country_name,president
US,USA,"Donald Trump"
RU,Russia,"Vladimir Putin"
CSV;

$etl = EtlBuilder::init()
    ->extractFrom(new CsvExtractor())
    ->loadInto(JsonFileLoader::factory(['json_options' => \JSON_PRETTY_PRINT]))
    ->createEtl();
$etl->process($data, __DIR__.'/data.json');
```

As you guessed, the following content was just written into `presidents.json`:

```json
[
    {
        "country_code": "US",
        "country_name": "USA",
        "president": "Donald Trump"
    },
    {
        "country_code": "RU",
        "country_name": "Russia",
        "president": "Vladimir Putin"
    }
]
```

We provide helpful extractors and loaders to manipulate JSON, CSV, text, and you'll also find a `DoctrineORMLoader` for when your transformer _yields_ Doctrine entities.

Because yes, a transformer must return a `\Generator`. Why? Because a single extracted item can lead to several output items. Let's take a more sophisticated example:

```php
use BenTools\ETL\EtlBuilder;
use BenTools\ETL\Extractor\JsonExtractor;

$pdo = new \PDO('mysql:host=localhost;dbname=test');
$input = __DIR__.'/presidents.json';

$etl = EtlBuilder::init()
    ->extractFrom(new JsonExtractor())
    ->transformWith(
        function ($item) use ($pdo) {
            $stmt = $pdo->prepare('SELECT country_code FROM countries WHERE country_code = ?');
            $stmt->bindValue(1, $item['country_code'], \PDO::PARAM_STR);
            $stmt->execute();
            if (0 === $stmt->rowCount()) {
                yield ['INSERT INTO countries (country_code, country_name) VALUES (?, ?)', [$item['country_code'], $item['country_name']]];
            }

            yield ['REPLACE INTO presidents (country_code, president_name) VALUES (?, ?)', [$item['country_code'], $item['president']]];

        }
    )
    ->loadInto(
        $loader = function (\Generator $queries) use ($pdo) {
            foreach ($queries as $query) {
                list($sql, $params) = $query;
                $stmt = $pdo->prepare($sql);
                foreach ($params as $i => $value) {
                    $stmt->bindValue($i + 1, $value);
                }
                $stmt->execute();
            }
        }
    )
    ->createEtl();

$etl->process(__DIR__.'/presidents.json'); // The JsonExtractor will convert that file to a PHP array
```

As you can see, from a single item, we loaded up to 2 queries.

Your _extractors_, _transformers_ and _loaders_ can implement [`ExtractorInterface`](https://github.com/bpolaszek/bentools-etl/tree/master/src/Extractor/ExtractorInterface.php), [`TransformerInterface`](https://github.com/bpolaszek/bentools-etl/tree/master/src/Transformer/TransformerInterface.php) or [`LoaderInterface`](https://github.com/bpolaszek/bentools-etl/tree/master/src/Loader/LoaderInterface.php) as well as being simple `callables`.

Skipping items
--------------

Each _extractor_ / _transformer_ / _loader_ callback gets the current `Etl` object injected in their arguments.

This allows you to ask the ETL to skip an item, or even to stop the whole process:

```php
use BenTools\ETL\Etl;
use BenTools\ETL\EtlBuilder;
use BenTools\ETL\Transformer\CallableTransformer;

$fruits = [
    'apple',
    'banana',
    'strawberry',
    'pineapple',
    'pear',
];

$storage = [];
$etl = EtlBuilder::init()
    ->transformWith(new CallableTransformer('strtoupper'))
    ->loadInto(
        function ($generated, $key, Etl $etl) use (&$storage) {
            foreach ($generated as $fruit) {
                if ('BANANA' === $fruit) {
                    $etl->skipCurrentItem();
                    break;
                }
                if ('PINEAPPLE' === $fruit) {
                    $etl->stopProcessing();
                    break;
                }
                $storage[] = $fruit;
            }
        })
    ->createEtl();

$etl->process($fruits);

var_dump($storage); // ['APPLE', 'STRAWBERRY']
```

Events
------

Now you're wondering how you can hook on the ETL lifecycle, to log things, handle exceptions, ... This library ships with a built-in Event Dispatcher that you can leverage when:

* The ETL starts
* An item has been extracted
* The extraction failed
* An item has been transformed
* Transformation failed
* Loader is initialized (1st item is about to be loaded)
* An item has been loaded
* Loading failed
* An item has been skipped
* The ETL was stopped
* A flush operation was completed
* A rollback operation was completed
* The ETL completed the whole process.

The _ItemEvents_ (on extract, transform, load) will allow you to mark the current item to be skipped, or even handle runtime exceptions. Let's take another example:

```php
use BenTools\ETL\EtlBuilder;
use BenTools\ETL\EventDispatcher\Event\ItemExceptionEvent;

$fruits = [
    'apple',
    new \RuntimeException('Is tomato a fruit?'),
    'banana',
];

$storage = [];
$etl = EtlBuilder::init()
    ->transformWith(
        function ($item, $key) {
            if ($item instanceof \Exception) {
                throw $item;
            }

            yield $key => $item;
        })
    ->loadInto(
        function (iterable $transformed) use (&$storage) {
            foreach ($transformed as $fruit) {
                $storage[] = $fruit;
            }
        })
    ->onTransformException(
        function (ItemExceptionEvent $event) {
            echo $event->getException()->getMessage(); // Is tomato a fruit?
            $event->ignoreException();
        })
    ->createEtl();

$etl->process($fruits);

var_dump($storage); // ['apple', 'banana']
```

Here, we intentionnally threw an exception during the _transform_ operation. But thanks to the event dispatcher, we could tell the ETL this exception can be safely ignored and it can pursue the rest of the process.

You can attach as many event listeners as you wish, and sort them by priority.

Recipes
-------

A recipe is an ETL pattern that can be reused through different tasks.
If you want to log everything that goes through an ETL for example, use our built-in Logger recipe:

```php
use BenTools\ETL\EtlBuilder;
use BenTools\ETL\Recipe\LoggerRecipe;

$etl = EtlBuilder::init()
    ->useRecipe(new LoggerRecipe($logger))
    ->createEtl();
```

You can also create your own recipes:

```php
use BenTools\ETL\EtlBuilder;
use BenTools\ETL\EventDispatcher\Event\ItemEvent;
use BenTools\ETL\Extractor\JsonExtractor;
use BenTools\ETL\Loader\CsvFileLoader;
use BenTools\ETL\Recipe\Recipe;

class JSONToCSVRecipe extends Recipe
{
    /**
     * @inheritDoc
     */
    public function updateBuilder(EtlBuilder $builder): EtlBuilder
    {
        return $builder
            ->extractFrom(new JsonExtractor())
            ->loadInto($loader = CsvFileLoader::factory(['delimiter' => ';']))
            ->onLoaderInit(
                function (ItemEvent $event) use ($loader) {
                    $loader::factory(['keys' => array_keys($event->getItem())], $loader);
                })
            ;
    }

}

$builder = EtlBuilder::init()->useRecipe(new JSONToCSVRecipe());
$etl = $builder->createEtl();
$etl->process(__DIR__.'/presidents.json', __DIR__.'/presidents.csv');
```

The above example will result in `presidents.csv` containing:
```csv
country_code;country_name;president
US;USA;"Donald Trump"
RU;Russia;"Vladimir Putin"
```

To sum up, a _recipe_ is a kind of an `ETLBuilder` factory, but keep in mind that a recipe will only **add** event listeners to the existing builder but can also **replace** the builder's _extractor_, _transformer_ and/or _loader_.

Tests
-----

```bash
./vendor/bin/phpunit
```

License
-------

MIT

repository: bpolaszek/bentools-etl

gha_language: PHP

repo_name: bpolaszek/bentools-etl


text:
---
layout: blogpost
title: Calling stuff "Christian"
subhead: A label that befits only people, not stuff
permalink:
categories: faith
---

Recently I saw a tweet about “top 10 Christian cartoons.”  My next thought was, “why do I typically ignore stuff when it’s labeled ‘Christian’?”

I have a very good answer that has nothing to do with being ashamed of my own faith, the Gospel, or Jesus. I stand boldly for those things, but often when I see something labeled "Christian" I cringe a little bit inside.

The reason I instinctively ignore just about anything that slaps the word “Christian” before it is because I've found that typically it is a complete misuse of the word as an adjective for the noun to which it is being ascribed.

There are only a very select group of things that can appropriately be labeled “Christian”, and it does not include the following cliche religious objects:

1. “Christian” Clothing. This includes t-shirts, entire clothing lines, accessories like a “Jesus First” pin, etc.
2. “Christian” Music.
3. “Christian” Movies
4. “Christian” Concerts or Festivals (see no. 2)
5. “Christian” Cruises. Really???
6. “Christian” books (including comics or cartoons)
7. “Christian” food. One word: Testamints.
8. “Christian” companies.

## Why that word fails us

## So what DOES warrant the use of the term “Christian” as an adjective?

First of all, let’s be clear here that the word “Christian” was originally used as a noun to slander a group of people who simply called themselves followers/disciples of Jesus - or more literally to the Biblical account, followers of the “the Way.” So the origins of the term "Christian" come from describing people, not stuff.

In adjective form, the word “Christian” literally means “Christ-like,” or “little Christ.” People who did not follow Jesus actually used the term about early disciples of Jesus to mock them. But still, we see that it has a direct correlation to the aspect of being a person, and your relationship as a person to Jesus Christ (as a follower or an imitator of).

This is why I take such issue with the term “Christian” being thrown around so loosely to refer to things like clothing, music, or books.

I get what is happening here from a cultural perspective. The people who hold to values that are consistent with a Biblical model are seeking a simple way to identify things that match up with that same model. I totally get that, and I think it's a natural tendency for people to have. We naturally look for things we identify with, and ways to communicate that we identify with things.

But I think it's lazy, and it's a HUGE mistake that does a tremendous diservice to the actual message of Jesus, and those who truly need to hear it most.

 And while there may be a shallow thread of connection between following Jesus and the crap that often gets ascribed as "Christian", we are polutting the actual message of Jesus by connect the idea of placing faith in him with our sentiments about material things that we think are somehow consistent with our faith.

Probably much of the time when the term “Christian” is used to refer to any of the above items it is far less noble than I'm trying to give credit for. Often it's actually just a sleezy way to market your product/service/item/event/xyz to an audience of people you know will take notice if you just slap the word "Christian" on it.

I see this all the time. People want to sell something to Christians, so they say, “I’m starting a Christian clothing company.” The motives might be legit (or not) but what they are really doing is just saying, “I want to sell clothes, and Christians are my target audience.”

## The secular and the sacred

What's just as maddening as [describe the above sentiment in summary here] is that using the term "Christian" as an adjective for things creates an artificial separation between the secular and the sacred, when a true Gospel inspired perspective on life sees all things as sacred.

----
*(points:)*

- There is a massive amount of cultural and political baggage associated with the term Christian.  While the term in itself should be quite neutral, in our culture it is anything but.

source: https://www.barna.org/barna-update/faith-spirituality/611-christians-more-like-jesus-or-pharisees#.UzQ3zK1dVih

-----
*(Conclusion paragraph)*

Whether the motives are pure, or more nefarious, using the term "Christian" to refer to anything other than people who are Jesus followers does a disservice to everybody. Let's just stop it.

---
reference:
http://faithlikes.com/2014/04/05/this-is-why-switchfoot-wont-sing-christian-songs-anymore/

license: MIT

branch_name: refs/heads/main

extension: md

gha_language: HTML

license_type: permissive


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

### Description

The expansion of '\h' in the prompt string in bash 4.3 allows remote authenticated users to execute arbitrary code via shell metacharacters placed in 'hostname' of a machine.

### POC

#### Reference
No PoCs from references.

#### Github
- https://github.com/ARPSyndicate/cvemon
- https://github.com/KorayAgaya/TrivyWeb
- https://github.com/Mohzeela/external-secret
- https://github.com/siddharthraopotukuchi/trivy
- https://github.com/simiyo/trivy
- https://github.com/t31m0/Vulnerability-Scanner-for-Containers
- https://github.com/umahari/security

repository: trickest/cve

gha_license_id: MIT

repo_name: trickest/cve


text:
---
layout: default
---

# 1995-01-31 - Re: Is the remailer crisis over?

## Header Data

From<EMAIL_ADDRESS>(Anonymous)

To<EMAIL_ADDRESS>Message Hash: 3c0a61341adfcbd12002db15031235408ba0ed5fb47f2feb30ab6e58c5b18715

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1995-01-31 10:52:50 UTC

Raw Date: Tue, 31 Jan 95 02:52:50 PST

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Anonymous)
Date: Tue, 31 Jan 95 02:52:50 PST
To<EMAIL_ADDRESS>Subject: Re: Is the remailer crisis over?
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Samuel Kaplin<EMAIL_ADDRESS>wrote:

> Well folks as of 11:30 on 1-30-94 there are 14 remailers with uptimes
> greater than 99%. What's the consensus...Is the remailer crisis over?

It'll be over when they are equally distributed across countries, not
90+% in the USA as is currently the case.  However, 14 is a good start
and perhaps the Rest Of The World will catch up.

{% endraw %}
```

## Thread

+ Return to [January 1995](/archive/1995/01)

+ Return to<EMAIL_ADDRESS>(Anonymous)](/authors/nobody_at_eniac_ac_siue_edu_anonymous_)"

+ 1995-01-31 (Tue, 31 Jan 95 02:52:50 PST) - Re: Is the remailer crisis over? -<EMAIL_ADDRESS>(Anonymous)_

branch_name: refs/heads/master


text:
---
title: "setDefaultAccount"
description: "An OpenIdConnect identity, for example an IAMid, can be linked or mapped to one or more individual SoftLayer users, but... "
layout: "method"
tags:
    - "method"
    - "sldn"
    - "User"
classes:
    - "SoftLayer_User_Customer_OpenIdConnect"
aliases:
    - "/reference/services/softlayer_user_customer_openidconnect/setDefaultAccount"
---
# [SoftLayer_User_Customer_OpenIdConnect](/reference/services/SoftLayer_User_Customer_OpenIdConnect)::setDefaultAccount

Sets the default account for the OpenIdConnect identity that is linked to the current SoftLayer user identity.

## Overview
An OpenIdConnect identity, for example an IAMid, can be linked or mapped to one or more individual SoftLayer users, but no more than one per account. If an OpenIdConnect identity is mapped to multiple accounts in this manner, one such account should be identified as the default account for that identity. Invoke this only on IBMid-authenticated users.

-----

### Parameters
|Name | Type | Description |
| --- | --- | --- |
|providerType| string| A value representing the OpenID Connect provider type. Currently "IBMid" is the only supported provider.|
|accountId| integer| The Softlayer account to set as default.|

### Required Headers
* authenticate
* SoftLayer_User_Customer_OpenIdConnectInitParameters

### Optional Headers
* SoftLayer_User_Customer_OpenIdConnectObjectMask
* SoftLayer_ObjectMask

### Return Values
* <a href='/reference/datatypes/SoftLayer_Account'>SoftLayer_Account </a>

gha_license_id: NOASSERTION


text:
---
id: create-plugin-api-v2
title: Create Plugin API v2
sidebar_label: Create Plugin API v2
---

To reduce complexity within Backstage core we're moving away from the current implementation of the Plugin API. And as we change a lot under the hood, we also want to enhance the usability of the API that contributors interact with. In general we want to reduce the touch area for developers and provide a clean way of getting the job done, no extra characters or functionality unless necessary. Here is our current solution. Try it out on your plugins and tell us what you like and what can be improved.

## `createPlugin` Function

> This replaces the Plugin class creation that previously extended `PluginBase`. Instead of exporting a class you now export the result of calling `createPlugin` with your plugin configuration.

Example of registering routes.

```javascript
import React from "react";
import { createPlugin } from "shared/pluginApi";

const OverviewPage = React.lazy(() => import("./OverviewPage"));
const AwesomePage = React.lazy(() => import("./AwesomePage"));

export default createPlugin({
  manifest: require("./plugin-info.yaml"),

  register({ router }) {
    router.registerRoute("/entity/:entityId", OverviewPage);
    router.registerRoute("/entity/:entityId/awesome", AwesomePage);
  }
});
```

## Plugin Configuration

As seen above, the object passed to `createPlugin` contains a `manifest` and a `register` property.

### `manifest`

The manifest is the same old yaml as before.

### `register`

The `register` function is similar to the current `initialize` method on PluginBase. Calling the new function "register" makes its intention clear, this is where you register your routes, feature flags, etc. It's not a place for any other type of business logic and you shouldn't trigger side effects here.

Notice the object parameter of the function. It is an object with predefined APIs that allow registrations. In the example we destructure the object to get `router`. But as of this writing it also contains `featureFlags` and `menu`.

These are the APIs and their registration signatures. See TS types in `/shared/pluginAPI/createPlugin.ts`.

```javascript
{
  router: {
    registerRoute: (path, Component, options = {}),
    registerRedirect: (path, target, options = {})
  },
  menu: {
    add: (options),
  },
  featureFlags: {
    register: (id),
    get: (id),
  }
}
```

repository: fengypants/backstage-microsite

repo_name: fengypants/backstage-microsite


text:
---
layout: base
title:  'Xavante UD'
udver: '2'
---

# UD for Xavante

## Tokenization and Word Segmentation

* Xavante uses all 17 [UPOS](https://universaldependencies.org/u/pos/index.html).
* Tokenization and semgmentatoin in Xavante is not straightforward, since descriptions do not agree among themselves.
* In general, words are delimited by whitespace characters. Description of exceptions follows.
* According to typographical rules, many punctuation marks are attached to a neighboring word. We always tokenize them as separate tokens (words).

Mapping UPOS to XPOS Xavante

 UPOS | XPOS |
:----: | :------: |
 ADJ   | adj      |
 ADV   | adv      |
 INTJ  | intj     |
 NOUN  | n        |
 PROPN | ppn      |
 VERB  | v, vi, vt|
 ADP   | pp       |
 AUX   | aux      |
 CCONJ | cc       |
 DET   | det      |
 NUM   | num      |
 PART  | pcl      |
 PRON  | pro      |
 SCONJ | sc       |
 PUNCT | punct    |
 SYM   | sym      |
 X     | x        |

## Morphology

### Tags

* Xavante (typological profile)

### Features

NOMINAL FEATURE
* Nominal words, NOUN, PROPN and PRON, are not marked for Gender, plural or animacy.
* There are no classifiers.
* The two main values of the Number feature are Sing and Plural.
* The notion of plural is expressed through numerals, particles or through reduplication:

### Person indexes

Xavante has a complicated system of indexation, using many different sets of markers. These are given in the tables below.

* Xavante has postpositions

* Nominal Reduplication: it marks pluralilty in nouns, as in *pi-pi* ‘feetʼ. It can be monosyllabic (involving the first or the second syllable of the stem) or dissyllabic. Reduplication is associated with the feature-value `Redup`.

* Augmentative and diminutive: the diminutive morpheme is -*tin* `Dim` and the augmentative -*atʃo* `Augm`. These morphemes refer to the size of something or the expansion of an event (if it is big or not).

VERBAL FEATURE

* Some verbs occur with the morpheme -*ka*, which is a transitivizer. This [feature](https://universaldependencies.org/u/feat/index.html) (`Trans`) takes the value YES if the when the morpheme is present.  Verbs that may or not combine with this morpheme take no overt object or require two obligatory arguments.

* Verbal Reduplication: it assigns aspectual function in verbs, as in *ãbi-bi* ‘to pull successively.ʼ As in the nouns, it can be monosyllabic (involving the first or the second syllable of the stem) or dissyllabic. Reduplication is associated with the feature-value `Redup`.

* Nominalization: there are two productive nominalizer affixes in this language: -ap `Nmzr=Circ`and i- `Nmzr=Obj`.

### Wh-words

Xavante wh-words are built from words such as  _wa_ 'who', _marĩ_ 'what' (man's speech), _tiha_ 'what' (woman's speech), _mamɛ_ 'where', _mahãta_ 'where is', and _momo_ 'where to'. These are, in questions, predeced by the particle _e_, which indicates that the speaker requires new information.

 UPOS        | XPOS      |
:----------: | :------:  |
 who          | _e wa_    |
 what (man)   |  _e marĩ_  |
 what (woman)  | _e tiha_  |
por quê? (man) | _e marĩ bə_ |
por quê? (woman)| _e tiha bə_ |
where           | _e mamɛ_  |
where to        | _e momo_  |
where (is)      | _e mahãta_ |

## Syntax

---

## Treebanks

There are [N](../treebanks/xav-comparison.html) Xavante UD treebanks:

  * [Xavante-A](../treebanks/xav_a/index.html)
  * [Xavante-B](../treebanks/xav_b/index.html)

---
**Instruction**: Treebank-specific pages are generated automatically from the README file in the treebank repository and
from the data in the latest release. Link to the respective `*-index.html` page in the `treebanks` folder, using the language code
and the treebank code in the file name.

---

repository: UniversalDependencies/docs

branch_name: refs/heads/pages-source

repo_name: UniversalDependencies/docs


text:
The Form component can be used with any React Atlas input component. The Form component does not style child
components by default and will ignore inputs without a name prop.

Basic Form with action prop:

		<Form action={"/some/random/url"}>
		  <TextField small placeholder="Text" required type="text" name="textName"></TextField>
			<Button type="submit">Submit</Button>
		</Form>

Form with onSubmit prop:

		<Form onSubmit={function(event, data) {console.log("event: ", event); console.log("data: ", data);}}>
		  <TextField small placeholder="Email" required type="email" name="email"></TextField>
		  <TextField small placeholder="Password" required type="password" name="password"></TextField>
		  <TextField small placeholder="Confirm Password" required type="password" name="confirm"></TextField>
			<Button type="submit">Submit</Button>
		</Form>

Form with onError prop:

	<Form onError={function(errorMsg){console.log(errorMsg)}} onSubmit={function(event, data) {console.log("event: ", event); console.log("data: ", data);}}>
	  <TextField small placeholder="Email" required type="email" name="email"></TextField>
	  <TextField small placeholder="Password" required type="password" name="password"></TextField>
	  <TextField small placeholder="Confirm Password" required type="password" name="confirm"></TextField>
		<Button type="submit">Submit</Button>
	</Form>

repository: nathanwomack/react-atlas

gha_language: JavaScript

repo_name: nathanwomack/react-atlas


text:
# tf-pose-estimation

'Openpose' implementation using Tensorflow to suit real-time processing on the CPU or low-power embedded devices.

Original Repo(Caffe) : https://github.com/CMU-Perceptual-Computing-Lab/openpose

## Install

### Dependencies

* python3.6
* tensorflow 1.4.1+
* opencv3, protobuf, python3-tk
* slidingwindow
  - https://github.com/adamrehn/slidingwindow
  - I copied from the above git repo to modify few things.

### Install

* Install this repo as a shared package using pip.

  ```bash
  $ git clone https://www.github.com/saswat0/tf-pose-estimation
  $ cd tf-pose-estimation
  $ python setup.py install  # Or, `pip install -e .`
  ```
* Install _pafprocess
  ```bash
  $ sudo apt install swig
  $ cd tf_pose/pafprocess/
  $ swig -python -c++ pafprocess.i
  $ python3 setup.py build_ext --inplace
  ```

### Download Tensorflow Graph File(pb file)

Before running demo, you should download graph files. You can deploy this graph on your mobile or other platforms.

- cmu (trained in 656x368)
- mobilenet_thin (trained in 432x368)
- mobilenet_v2_large (trained in 432x368)
- mobilenet_v2_small (trained in 432x368)

CMU's model graphs are too large for git, so I uploaded them on an external cloud. You should download them if you want to use cmu's original model. Download scripts are provided in the model folder.

```
$ cd models/graph/cmu
$ bash download.sh
```


text:
---
layout: layout.pug
navigationTitle: Configuration Requirements
title: Configuration Requirements
menuWeight: 7
excerpt: KBA Descriptions and Resource Requirements
beta: false
enterprise: false
---

<!-- markdownlint-disable MD018 -->

#include /dkp/konvoy/1.8/include/kba-requirements.tmpl

#include /dkp/konvoy/1.8/include/kba-addons-versions.tmpl

## Related information

For information on related topics or procedures, refer to the following:

- [Introduction to KBA](../../addons)
- [Current KBA Release Information](../../release-notes/kubernetes-base-addon)

repository: mesosphere/dcos-docs-site

gha_language: SCSS

repo_name: mesosphere/dcos-docs-site


text:
# dhis2-android-trackercapture
Android application for DHIS 2 for tracking of persons and things.

Get the APK from the release page:

https://github.com/dhis2/dhis2-android-trackercapture/releases

# Testing
If you want to try the application out with a demo database, you can use the following:
- Server: https://apps.dhis2.org/demo
- Username: android
- Password: Android123

#How to Download and Set up in Android Studio
To successfully build and run this project, the dhis2-android-sdk is required.

The dhis2-android-sdk project https://github.com/dhis2/dhis2-android-sdk folder should be in the same root folder as the dhis2-android-trackercapture.
A workspace folder structure would look like this:

> .

> ..

> dhis2-android-sdk

> dhis2-android-trackercapture

Then open Android Studio, select "Open an existing Android Studio project", and select the build.gradle in dhis2-android-trackercapture/

gha_language: Java


text:
# SUSE::BuildCheckStatistics

  A [Mojolicious](http://mojolicious.org) application for collecting statistics
  about rpmlint failures in [Open Build Service](http://openbuildservice.org/)
  projects.

![Screenshot](https://raw.githubusercontent.com/openSUSE/build-check-statistics/master/screenshot.png)

## Installation

  All you need is a one-liner, it takes less than a minute.

    $ curl -L https://cpanmin.us | perl - -n git://github.com/openSUSE/build-check-statistics.git@master

  We recommend the use of a [Perlbrew](http://perlbrew.pl) environment.

## Setup

Just create a configuration file under `/etc/build_check_statistics.conf`.

```
{
  obs       => 'https://build.opensuse.org/public',
  projects  => ['SomeProject', 'AnotherProject'],
  sqlite    => 'sqlite:/var/lib/build_check_statistics/test.db',
  hypnotoad => {
    pid_file => '/var/lib/build_check_statistics/hypnotoad.pid'
  }
}
```

Or a different location chosen with the `SUSE_BCS_CONFIG` environment
variable.
```
SUSE_BCS_CONFIG=/home/sri/.build_check_statistics.conf
```

Update and deploy statistics. This can be repeated at any time to update the
data.
```
$ build_check_statistics update
$ build_check_statistics deploy
```

![Screenshot2](https://raw.githubusercontent.com/openSUSE/build-check-statistics/master/screenshot2.png)

Start the web server.
```
$ build_check_statistics daemon -m production
```

repository: openSUSE/build-check-statistics

repo_name: openSUSE/build-check-statistics


text:
# sublime-webi-syntax
Business Objects Web Intelligence syntax highlighting for Sublime text editor

Built with [PackageDev](https://github.com/SublimeText/PackageDev)


text:
# HADropDown
HADropDown is a simple iOS drop down list written in Swift. It expands and collapses. It allows the user to select only one item at a time. Items are just Strings. A delegate is notified when selection occurs. HADropDown is IBDesignable and IBInspectable with customizable colors, font, and row heights.
![Alt text](https://github.com/Hassan-Aftab/HADropDown/blob/master/Simulator%20Screen%20Shot?raw=true "Demo")

Simply include HADropDown.swift in your project. HADropDown requires Swift 3.
# Usage

Create a HADropDown in IB or in code (using UIView's init methods). Then add items and set a delegate:

dropDown.items = ["hello", "goodbye", "why?"]
dropDown.delegate = self
You can also implement HADropDownDelegate to get notified when an item is selected:

```javascript
func didSelectItem(dropDown: HADropDown, at index: Int) {
        print("Item selected at index \(index)")
    }
```
The delegate can also optionally implement the method
```javascript
func didShow(dropDown: HADropDown)
func didHide(dropDown: HADropDown)
```
to be notified when the collapse status of the menu changes.

Items can be added or removed

All properties can be manually modified.

# License and Authorship

Released under the MIT License. Copyright 2017-2018 Hassan Aftab. Please open issues on GitHub.


text:
---
layout: codelab
title: Address form best practices codelab
authors:
  - samdutton
scheduled: true
date: 2020-12-09
updated: 2020-12-09
description: Learn best practices for address forms.
tags:
  - ecommerce
  - forms
  - identity
  - layout
  - mobile
  - security
  - ux
glitch: address-form-codelab-0
glitch_path: index.html
related_post: payment-and-address-form-best-practices
---

How can you design a form that works well for a variety of names and address formats? Minor form
glitches irritate users and can cause them to leave your site or give up on completing a purchase
or sign-up.

This codelab shows you how to build an easy-to-use, accessible form that works well for most users.

## Step 1: Make the most of HTML elements and attributes

You'll start this part of the codelab with an empty form, just a heading and a button all on
their own. Then you'll begin adding inputs. (CSS and a little bit of JavaScript are already
included.)

{% Glitch {
  id: 'address-form-codelab-0',
  path: 'css/main.css',
  height: 300
} %}

{% Instruction 'remix' %}

* Add a name field to your `<form>` element with the following code:

```html
<section>
  <label for="name">Name</label>
  <input id="name" name="name">
</section>
```

That may look complicated and repetitive for just one name field, but it already does a lot.

You associated the `label` with the `input` by matching the `label`'s `for` attribute with the
`input`'s `name` or `id`. A tap or click on a label moves focus to its input, making a much bigger
target than the input on its own—which is good for fingers, thumbs and mouse clicks! Screenreaders
announce label text when the label or the label's input gets focus.

What about `name="name"`? This is the name (which happens to be 'name'!) associated with the data
from this input which is sent to the server when the form is submitted. Including a `name` attribute
also means that the data from this element can be accessed by the [FormData API](https://developer.mozilla.org/en-US/docs/Web/API/FormData/Using_FormData_Objects).

## Step 2: Add attributes to help users enter data

What happens when you tap or click in the **Name** input in Chrome? You should see autofill
suggestions that the browser has stored and guesses are appropriate for this input, given its
`name` and `id` values.

Now add `autocomplete="name"` to your input code so it looks like this:

```html/2
<section>
  <label for="name">Name</label>
  <input id="name" name="name" autocomplete="name">
</section>
```
Reload the page in Chrome and tap or click in the **Name** input. What differences do you see?

{% Aside %}
Ever wondered how to delete autofill suggestions in Chrome?
* Windows: `Shift` + `delete`
* Mac: `Shift` + `fn` + `delete`
{% endAside %}

You should notice a subtle change: with `autocomplete="name"`, the suggestions are now specific
values that were used previously in form inputs that also had `autocomplete="name"`. The browser
isn't just guessing what might be appropriate: you have control. You'll also see the **Manage…**
option to view and edit the names and addresses stored by your browser.

  {% Img src="image/tcFciHGuF3MxnTr1y5ue01OGLBn2/uSc6aqRgHoL2qIDyj803.jpg", alt="Two screenshots of Chrome on an Android phone showing a form with a single input, with and without an autocomplete value. One shows browser UI heuristicically suggestions values; the other shows UI when there are stored autocomplete values.", width="800", height="684" %}

UI for autofill with guessed values, versus autocomplete.

{% Aside %}
If an [appropriate autocomplete value](/payment-and-address-form-best-practices/#autocomplete-attribute)
is available for an `input`, `select` or `textarea`, you should use it!
{% endAside %}

Now add [constraint validation attributes](https://developer.mozilla.org/en-US/docs/Web/Guide/HTML/HTML5/Constraint_validation)
`maxlength`, `pattern` and `required` so your input code looks like this:

```html/2
<section>
  <label for="name">Name</label>
  <input id="name" name="name" autocomplete="name"
    maxlength="100" pattern="[\p{L} \-\.]+" required>
</section>
```

* `maxlength="100"` means the browser won't allow any input longer than 100 characters.

* `pattern="[\p{L} \-\.]+"` uses a regular expression that allows [Unicode letter characters](https://javascript.info/regexp-unicode),
hyphens and periods (full stops). That means names such as Françoise or Jörg aren't classed as
'invalid'. That isn't the case if you use the value `\w` which [only allows characters from the
[Latin alphabet](/payment-and-address-form-best-practices/#unicode-matching).

* `required` means… required! The browser will not allow the form to be submitted without data for
this field, and will warn and highlight the input if you attempt to submit it. No extra code
required!

{% Aside 'caution' %}
This codelab doesn't address (😜) localization or internationalization. Depending on where your users
are located, you need to consider address *formats* as well as the different *names* used for
address components, even within the same language: ZIP, postal code, Eircode or PIN? It may be
necessary for your site to [customize for multiple locales](https://www.smashingmagazine.com/2020/11/internationalization-localization-static-sites#determining-user-s-language-and-region),
but the address form in this codelab is designed for flexibility, and should work "well enough" for
a range of addresses.
{% endAside %}

To test how the form works with and without these attributes, try entering data:

* Try entering values that don't fit the `pattern` attribute.
* Try submitting the form with an empty input. You'll see built-in browser functionality warning of
the empty required field and setting focus on it.
## Step 3: Add a flexible address field to your form

To add an address field, add the following code to your form:

```html
<section>
  <label for="address">Address</label>
  <textarea id="address" name="address" autocomplete="address"
    maxlength="300" required></textarea>
</section>
```

A `textarea` is the most flexible way for your users to enter their address, and it's great for
cutting and pasting.

You should avoid splitting your address form into components such as street name and number unless
you really need to. Don't force users to try to fit their address into fields that don't make sense.

{% Aside %}
Consider the way that address data from your form is being used. What's it for? Make sure to
understand data requirements and who sets them.
{% endAside %}

Now add fields for **ZIP or postal code**, and **Country or region**. For simplicity,
only the first five countries are included here. A full list is included in the [completed address form](https://address-form.glitch.me).

```html
<section>
  <label for="postal-code">ZIP or postal code (optional)</label>
  <input id="postal-code" name="postal-code"
    autocomplete="postal-code" maxlength="20">
</section>

<section id="country-region">
  <label for="">Country or region</label>
  <select id="country" name="country" autocomplete="country"
    required>
      <option selected value="SPACER"> </option>
      <option value="AF">Afghanistan</option>
      <option value="AX">Åland Islands</option>
      <option value="AL">Albania</option>
      <option value="DZ">Algeria</option>
      <option value="AS">American Samoa</option>
  </select>
</section>
```

You'll see that **Postal code** is optional: that's because [many countries don't use postal codes](https://hellowahab.wordpress.com/2011/05/24/list-of-countries-without-postal-codes/).
([Global Sourcebook](https://www.grcdi.nl/gsb/global%20sourcebook.html) provides information about
address formats for 194 different countries, including sample addresses.) The label **Country or
region**  is used instead of **Country**, because some options from the full list (such as the
United Kingdom) are not single countries (despite the `autocomplete` value).

## Step 4: Enable customers to easily enter shipping and billing addresses

You've built a highly functional address form, but what if your site requires more than one
address, for shipping and billing, for example? Try updating your form to enable customers to enter
shipping and billing addresses. How can you make data entry as quick and easy as possible,
especially if the two addresses are the same? The article that goes with this codelab explains
[techniques for handling multiple addresses](/payment-and-address-form-best-practices#billing-address).
Whatever you do, make sure to use the correct `autocomplete` values!

## Step 5: Add a telephone number field
To add a telephone number input, add the following code to the form:

```html
<section>
  <label for="tel">Telephone</label>
  <input id="tel" name="tel" autocomplete="tel" type="tel"
    maxlength="30" pattern="[\d \-\+]+" enterkeyhint="done"
    required>
</section>
```

For phone numbers use a single input: don't split the number into parts. That makes it easier for
users to enter data or copy and paste, makes validation simpler, and enables browsers to autofill.

There are two attributes that can improve the user experience of entering a telephone number:
* `type="tel"` ensures mobile users get the right keyboard.
* `enterkeyhint="done"` sets the mobile keyboard enter key label to show that this is the last
field and the form can now be submitted (the default is `next`).

  {% Img src="image/tcFciHGuF3MxnTr1y5ue01OGLBn2/vReqMRQjLSI7e6UQ5WwX.png", alt="Two screenshots of a form on Android showing how the enterkeyhint input attribute changes the enter key button icon.", width="800", height="684" %}

Use the enterkeyhint attribute to set the Enter button label:
    'next' and 'done'.

{% Aside 'gotchas' %}
Using `type="number"` adds an up/down arrow to increment numbers, which makes no sense for data such
as telephone, payment card, or account numbers. Instead, you should use `type="tel"` for telephone
numbers. For other numbers, use `type="text"` (or leave off the attribute, since `text` is the
default) and add `inputmode="numeric"` to get a numeric keyboard on mobile.
{% endAside %}

{% Aside %}
Can you see any problems with using a single input for telephone number? Do you store phone
number parts (country and area code) separately? If so, why?
{% endAside %}

Your complete address form should now look like this:

{% Glitch {
  id: 'address-form',
  path: 'index.html',
  height: 970
} %}

* Try out your form on different devices. What devices and browsers are you targeting? How could
the form be improved?

There are several ways to test your form on different devices: {: #different-devices}

* [Use Chrome DevTools Device Mode](https://developers.google.com/web/tools/chrome-devtools/device-mode)
to simulate mobile devices.
* [Send the URL from your computer to your phone](https://support.google.com/chrome/answer/9430554).
* Use a service such as [BrowserStack](https://www.browserstack.com/open-source) to test on a range
of devices and browsers.

{% Aside %}
Before you start building forms, make sure to understand what data is required and if that data is
strictly necessary. Don't ask for data you don't need! The simplest way to reduce form complexity
and improve privacy is to remove unnecessary fields. Storing less data also reduces back-end data
cost and liability.
{% endAside %}

## Going further

* [Analytics and Real User Monitoring](/payment-and-address-form-best-practices#analytics-rum):
enable the performance and usability of your form design to be tested and monitored for real users,
and to check if changes are successful. You should monitor load performance and other [Web Vitals](/vitals),
as well as page analytics (what proportion of users bounce from your address form without completing
it? how long do users spend on your address form pages?) and interaction analytics (which page
components do users interact with, or not?)

* Where are your users located? How do they format their address? What names do they use for address
components, such as ZIP or postal code? [Frank's Compulsive Guide to Postal Addresses](http://www.columbia.edu/~fdc/postal/)
provides useful links and extensive guidance detailing address formats in over 200 countries.

* Country selectors are notorious for [poor usability](https://www.smashingmagazine.com/2011/11/redesigning-the-country-selector/).
It's [best to avoid select elements for a long list of items](https://baymard.com/blog/drop-down-usability#in-general-avoid-drop-downs-when-there-are-more-than-10-or-fewer-than-5-options)
and the ISO 3166 country-code standard [currently lists 249 countries](https://www.iso.org/obp/ui/#search/code/)!
Instead of a `<select>` you may want to consider an alternative such as the
  [Baymard Institute country selector](https://baymard.com/labs/country-selector).

  Can you design a better selector for lists with a lot of items? How would you ensure your design is
accessible across a range of devices and platforms? (The `<select>` element doesn't work well for a
  large number of items, but at least it's usable on virtually all browsers and assistive devices!)

  The blog post
  [<input type="country" />](https://shkspr.mobi/blog/2017/11/input-type-country/) discusses
  the complexity of standardizing a country selector. Localization of country names can also be
  problematic. [Countries Lists](http://www.countries-list.info/Download-List) has a tool for
  downloading country codes and names in multiple languages, in multiple formats.


text:
### Problem Statement:
```txt
This crocodile has many secrets. If you poke him enough, he will reveal the secret of his people.
```

---

We've been given the following image:

![secrets](secrets.jpg)

We can try and get some info about the file using several tools.
```zsh
$ exiftool secrets.jpg
Nope nothin here :P

$ strings secrets.jpg | grep "flag"
flag.pngUT
flag.pngUT
```

Well, this is certainly interesting... there's somethin named "flag.png" in there, maybe we can try and extract this?

We can use `binwalk` for the ease of singling out what tool to use, or just straight up get the file.
```zsh
$ binwalk secrets.jpg

DECIMAL       HEXADECIMAL     DESCRIPTION
--------------------------------------------------------------------------------
0             0x0             JPEG image data, JFIF standard 1.01
30            0x1E            TIFF image data, big-endian, offset of first image directory: 8
23256         0x5AD8          Zip archive data, at least v2.0 to extract, compressed size: 45158, uncompressed size: 52221, name: flag.png
68558         0x10BCE         End of Zip archive, footer length: 22

$ unzip secrets.jpg
Archive:  secrets.jpg
warning [secrets.jpg]:  23256 extra bytes at beginning or within zipfile
  (attempting to process anyway)
  inflating: flag.png

# or rather use:
$ binwalk -e secrets.jpg
# now view "_secrets.jpg.extracted/flag.png"
```

The file:
![flag](flag.png)

---

### The Flag:
    flag{the_crocodiles_attack_at_dawn}

Link to the challenge: [hidden files](https://training.majorleaguecyber.org/challenges#hidden%20files-6)

gha_language: Python


text:
# Fame bootstrap

Command line utility to bootstrap fame entities built with in GO with [viper](https://github.com/spf13/viper) and [cobra](https://github.com/spf13/cobra)

## Configuration file

#### Location
A configuration file is required in order to run this application.
The default path for the configuration file is `$HOME/.famebootstrap.yaml`
You can also pass an absolute path to your custom configuration file using the flag `config`

#### Content
A default configuration file can be found in this repo at `.famebootstrap.yaml`.
The baseUrl has to be setup for all three environments.

## How to use
Assuming you have access to the executable binary named `famebootstrap`, the list of available commands can be found:

### Help
You can get a list of all available commands
```
$ famebootstrap help
$ famebootstrap bootstrap --help

```
### Bootstrap
You can bootstrap a entire fame entity or a specific resource belonging to a fame entity
```
$ famebootstrap bootstrap [entityName] [resourceId]
```
- The **entityName** argument has to be the name of a valid entity from FAME.
- If the **entityName** argument is not passed as input, you will be required to enter an entity name during the program execution.
- The **entityName** argument has to be specified in order to use the resourceId argument
- If both the **entityName** and the **resourceId** arguments are specified, only that specific **resourceId** will be bootstrapped

The following flags can be passed as input:
- **-q** : The destination queue for the messages you are bootstrapping. If not specified, you will be prompted to enter one during the execution
- **-e** : The environment to be used for the bootstrap. If not specified, you will be prompted to enter one during the execution
- **-u** : A custom base url can be supplied here and it will override the base url provided in the configuration file
```
 $ famebootstrap bootstrap
 $ famebootstrap bootstrap match
 $ famebootstrap bootstrap stadium
 $ famebootstrap bootstrap match -e=GOLD -q=fsp
```

### Status
You can get the status of a running bootstrap
The argument **commandId** can be retrieved from the output of the bootstrap command
```
$ famebootstrap status {commandId}
```

## How to build
```
$ go get
$ go fmt path_to_source_code\fame-bootstrap
```
- Windows:
```
$ env GOOS=windows GOARCH=amd64 go build -o build/famebootstrap.exe
```
- Linux:
```
$ env GOOS=linux GOARCH=amd64 go build -o build/famebootstrap
```
Once the executable binary has been created, you can run it directly from the command line as explained in [how to use](#How-to-use) section
## how to run

The program can be run directly from the code using:
```
$ go run main.go {name_of_the_command} [args] [flags]
```
e.g.
`
$ go run main.go bootstrap match -q=fsp -e=PROD
`

repository: kamgastephane/fame-bootstrap

repo_name: kamgastephane/fame-bootstrap


text:
# Dialogflow

The dialogflow plugin makes it possible to connect Jeedom to Google Home / Assistant by a native application and interactions

> **NOTE**
>
> There is also the Google Smarthome plugin which allows you to connect Jeedom to Google Home / Assistant but this time for the sake of Google’s Smarthome integration, it therefore does not use interactions.

> **Important**
>
> The plugin requires a subscription to voice services. You can manage your subscription [here](https://market.jeedom.com/index.php?v=d&p=profils#services)

# Configuration

Install the plugin and activate it. Then always on the plugin configuration page click on "Send" to send your configuration to the market.

![dialogflow](./images/dialogflow1.png)

> **Important**
>
> You don't have to create any equipment for this plugin. Just follow the instructions below.

On the market you must activate "Google Smarthome" in the "My Services" tab".

> **Important**
>
> The access url of your jeedom must absolutely be in https

> **NOTE**
>
> You can only connect one Jeedom to Google per market account

On a phone with Google Assistant, say "Speak with Jeedom", Google will tell you to link your Jeedom account and Google click on yes :

![dialogflow](./images/dialogflow2.png)

Indicate your market identifiers :

![dialogflow](./images/dialogflow3.png)

Google will tell you that the configuration is successfully created / updated :

![dialogflow](./images/dialogflow4.png)

Here, the link between your Jeedom and Google Home / Assistant is made.

You can now talk to your Jeedom and use all the interactions of your Jeedom directly from your Google Home / Assistant.
From your Google Home / Assistant, just say "Talk to Jeedom", "Ask Jeedom" or even "Say to Jeedom" to start interaction with Jeedom and "Thank you" when you're done to end the conversation.

# FAQ

>**I have the error ESOCKETTIMEDOUT**
>
>Is that your URL or API key configured on the market is not good. Also pay attention to the response time defined in the interactions, Google imposes a response time before timeout of 4 seconds.

>**Error your Jeedom did not answer correctly ETIMEDOUT code. Something else**
>
>This comes from your Jeedom which did not respond within the allotted time (imposed by Google). It can come from 2 things, a slow internet connection, or actions that take too long.

repository: jeedom/documentations

repo_name: jeedom/documentations


text:
---
title: Importance of mita in te reo Māori
feature_image:
  image: https://res.cloudinary.com/whanganuihigh/image/upload/v1600585812/News/Leigh-Marama_McLachlan_Chron_19.9.20.jpg
  description: Former RNZ Māori news correspondent Leigh-Marama McLachlan said it
    made her proud to be able to speak her mita, dialect, on the national
    broadcaster.
  credit: Bevan Conley
news_author:
  date: 2020-09-19T07:08:02.337Z
  name: Michael Neilson
  publication: Whanganui Chronicle
image_gallery:
  - image: https://res.cloudinary.com/whanganuihigh/image/upload/v1600585866/News/Leigh-Marama_McLachlan_WU_river.jpg
    description: The Whanganui River. Photo / Eleanor Hughes.
show_in_slider: false
date: 2020-09-20T07:08:02.486Z
---
Former RNZ journalist Leigh-Marama McLachlan, whose first language is te reo Māori, used to have listeners email her after a story, concerned she was pronouncing her kupu wrong.

Instead of "whānau" for family, with a sharp "F" sound at the beginning, McLachlan would pronounce it "w'ānau".

"I'd get all these listeners emailing in, really concerned, saying, 'Your journalist is saying it all wrong!'"

But she'd take the time to respond, and explain that it was in fact her reo, her mita, or dialect.

"It was really bad when it was a story about Whānau Ora. But people were generally surprised, but interested."

McLachlan, of Te Ātihaunui ā Papārangi, grew up in Whanganui speaking her mita.

"It's just what we speak here, it's normal," she tells the Herald from Whanganui, where she returned to raise her tamariki among their mita, and work with her iwi.

Mita can involve dropping a consonant, a glottal stop or replacing a letter with another, and are all unique indicators of the country's different iwi.

Mita also include different kupu/words, whakatauki/idioms, tikanga/customs and waiata/songs.

In Northland with Ngāpuhi, instead of hearing whakarongo, to listen - with a sharp "F" sound at the beginning - you are more likely to hear it being pronounced as "hakarongo".

Tūhoe speakers change the "ng" sound into an "n" sound and whakarongo becomes "whakarono".

Ngāi Tahu - Kai Tahu - in the South Island change the "ng" sound into a "k" sound and it becomes: "whakaroko".

In Whanganui they say "ana" for yes, instead of "āe", which is heard across most of Aoteaora.

But the most distinct aspect is the "Wh", which is like a "W" with a really soft almost non-existent "H".

"It's not uncommon for the kaikorero (speaker on marae) to poke fun at us for it. But it is really cool, I love being from Whanganui," said McLachlan, pronouncing the name of her city with a soft H.

The sound is believed to have come from the whisping noise the wind made further up their awa tūpuna, Whanganui, McLachlan said.

So significant is mita, that when the "H" was restored into the official name of city in 2015, Ngāti Rangi historian Che Wilson previously told the Herald "everybody in the room cried".

"Wanganui" has no meaning, whereas "Whanganui" refers to "the long wait", which originated from Te Whanga-nui-a-Kupe, referring to the extended wait for the return of the great Pacific navigator Kupe from his exploration.

McLachlan said she was really proud to speak it on RNZ, to represent her iwi, and raise awareness.

"Our dialects are so people know where we are from, so Māori from across the motu can identify our roots.

"It acknowledges tūpuna, whakapapa, whanaungatanga - it is our reo"

University of Auckland Te Puna Wānanga senior lecturer Dr Peter J Keegan, of Waikato-Maniapoto and Ngāti Porou, said mita were becoming less common as there was more mingling.

"The difference between now and, say, the 1700s is that people were very isolated then and didn't talk between each other a great deal.

"Whereas now a lot of people are moving around, living together in urban areas, and there is a levelling of the dialects."

It was similar to English, with dialects lost over time, and evolving - such as the Kiwi dialect, heavily influenced by Māori.

However within iwi and the regions, mita remained strong.

Keegan said he used mita in formal settings as an identifier, but in general conversation he would revert to a more general reo Māori.

Over time he saw dialects of the Far North and eastern North Island iwi as dominating, as that was where most people came from.

"We have recordings of mita - we are not going to lose them. But for now for me, it is more important to have people speaking te reo, than worrying about mita.

"My advice is learn as much as you can, where you can, and in how you can fit it into your life.

"Then once you are proficient and want to learn a dialect those doors are open to you."

University of Waikato te reo Māori lecturer Dr Ēnoka Murphy, who has been teaching te reo for more than 30 years and still seen it decline, said the most important thing right now was to learn te reo.

The percentage of Māori being able to speak te reo has dropped from over 25 per cent in 2001 to under 19 per cent in 2018.

While wānanga outside the main centres would likely be teaching in the mita of their rohe, in more urban areas, like Kirikiriroa where he taught, they used a more common reo.

"One we can all understand," Murphy said.

But in his classes he impressed on his tauira the importance of mita, and had fears it would become less common.

"Mita is everything.

Te Mātāwai is an independent entity set up under Te Ture mō Te Reo Māori (the Māori Language Act), which aims to promote the use of te reo in homes and the community.

Its Maihi Māori 2017-2040 Strategy, compiled through hui with stakeholders nationwide, includes high-level objectives to promote te mita o te reo Māori of iwi, hapū and whānau.

Kaiwhakahaere rangahau Ria Tomoana said their organisation provided funding for initiatives to enhance mita, with examples including iwi compiling databases of kupu specific to them.

"Te Mātāwai aims to return the language into a nurturing language, a language you can grow up with, and that locates you to where you are.

"There is a role for standardisation when there is nothing. But now there is a good fabric, and these mita make it all the richer."

gha_language: Blade


text:
---
layout: article
title: "Uploading to Google Drive — Without Google Drive"
modified:
categories: blog
tags: [Music, Tech Tools]
image:
  feature: google-feature.jpg
  teaser: google-teaser.jpg
  thumb:
date: 2015-08-11T08:50:13-04:00
---

Cloud-based services like Google Drive and Dropbox can be great ways to have students submit assignments. When students submit work online, you have a digital file that's hard to lose (and they do too), the file is accessible almost anywhere, and its timestamped.

In the past, I've used Google Drive as a place for students to submit counterpoint assignments—which I grade digitally using [iAnnotate](http://www.iannotate.com) on my iPad; formal diagrams created with [Variations Audio Timeliner](http://flipcamp.org/engagingstudents2/essays/moseley.html); and most successfully, to [submit prepared singing assignments](http://flipcamp.org/engagingstudents/deClercq.html) that they've [recorded on their smartphones](http://briancmoseley.com/dropvox/) or through their computer.

But uploading a file to Google Drive or Dropbox requires students to have an account associated with one of those services. If you're going to have them submit assignments regularly, it's probably worth having them sign up for a Drive account. Often enough, though, these are one-off submissions in my class, and signing up for a Drive account is more trouble than it's worth.

A few months ago I used [Google Apps Script](https://developers.google.com/apps-script/?hl=en) to create a form for submitting files to Google Drive—all without logging into a Drive account. The form was designed for other purposes, but it can used to submit any kind of file along with identifying information. Your students simply visit a webpage, enter their name and any other information you want to record, and upload the file. It's completely customizable. The files will show up in a Google Drive folder that you specify and that only you (or you and your TAs) can access.

You can try it by [following this link](https://script.google.com/macros/s/AKfycbxENcuU8p2tIbFS_tspe2a-yYtu47V6DwNGbBV2YcjkkOlznbXa/exec). Submit a file and you can [see the submission data here](
).

Assuming you already have a Google Drive account, here's how to do it. I promise, it's not that difficult!

###Create a copy of the script file in your  Google Drive folder
Follow [this link](https://script.google.com/d/1S4cAW34AjabzbqmZvAYVduvUIPKxOPTzPZBJEzm-LQ6DRTpv8lU2ceP-/edit?usp=sharing). In the menu, choose "File > Make a Copy" to save it to your Drive, and give it a name that you'll remember.

Follow the link, make a copy.

###Create a submission folder and spreadsheet

In Google Drive, create a new folder. You can name this anything you'd like, but it should be easy to identify. Drag the script file you into this folder, and while you're there, create a new "Google Sheet" and give it a name. This sheet will be used to store submission data.

Create a submissions folder and store the script file inside, along with a spreadsheet  for the submitted data.

###Link the script file

You need to link the script to your Google Drive and to the Submissions folder and spreadsheet you created. To do this you'll need to replace some values in 'Code.gs. If you're not familiar with HTML or JavaScript, some of this will look kind of opaque. But don't worry. You don't need to understand it all, and there are plenty of comments in the code that will show you how to make changes.

First, open the script file, and on the left side select "Code.gs".

The keys you need to replace are on lines 6 and 8.

In the code block, the really long string of random characters next to **var submissionSSid** stores a "key" that links the script to a spreadsheet. You'll need to replace that string with one associated with the Google sheet you created earlier. To find that value, open the Google Sheet you created. Copy the really long string of random characters after "/d/" and before "/edit" and paste it into the code.

It's the long string following "/d/".

Now, you need to do the same thing to the value next to 'folderId.' To find the folder ID, open the submissions folder and it will be the really, really long string of random characters after "/folders/". Again, copy and paste it into the script. You're almost done!

It's the long string following "/folders/"..

###Customize the script
Comments in the script will tell you how to add custom input fields. In general, changes you make to 'Form.html' should have a corresponding change in 'Code.gs'. For example, if I wanted to add a input field for a student to enter their class section below the email input, make this change to 'Form.html':

{% highlight html%}
{% raw %}

Email
<input name="email" type="text"/>

Section
<input name="section" type="text"/>

{% endraw %}
{% endhighlight %}

And add this to 'Code.gs':

First, in the {% raw %}function processForm(theForm){% endraw %} section:

{% highlight js%}
{% raw %}
//Get the name of the assignment
var assignmentName = theForm.assignmentName;
//Get the student's name
var name = theForm.name;
//Student Email
var email = theForm.email;
//Add new fields here:
var section = theForm.section;
{% endraw %}
{% endhighlight %}

See how `var section = theForm.section` relates to `<input> name="section" type="text"/>`?

Finally, next to `var targetRange`:

{% highlight js%}
{% raw %}
var targetRange = sheet.getRange(lastRow+1, 1, 1, 5).setValues([[name,email,assignmentName,assignmentURL, section]]);
{% endraw %}
{% endhighlight %}

###Save and Deploy
Once you've made all of your changes, you publish the script as a web app and Google gives you a web address where the form lives. To do this, select "Publish > Deploy as Web App...". Under, "Who has access to the app:", select "Anyone, even anonymous," and the click "Deploy."

Google will ask for authorization, and you should select OK. The link you get after deploying will be where your form lives. To make changes later, just "deploy" the app again. You'll have to create a new version.


text:
# Print Server
## Compilation
- create the printer/drivers directory
- cd printer && make && cd ..
- make

## Launching the test
- sh start_drivers.sh
- sh test.sh | ./printserver -l test.log

## Test Case
The provided test.sh sends 48 jobs to the print server.
These are relatively evenly divided between color and black/white.

No additional files are used beyond the provided samplec.ps.

## Test Results
To verify test success, run
~~~
find . -name 'output*.pdf' | wc -l
~~~
48 files should be created.

When EXIT is received, the main thread will print a waiting message and
set the kill flag. The program will not terminate until all pending jobs
have been handled and all threads have terminated.

The test.log file will detail start and stop times of each job. The duration
is reported to one-second resolution.

NB: The one second resolution is too broad for the given file with virt-printer. All
durations report 0 seconds.


text:
# [The Twelve-Factor App](https://12factor.net/)

The twelve-factor for micro service

微服务的12个要素

刚刚看到相关文章提到此概念，记录一下

Just saw the related article mentioned this concept, record it.

1. Codebase
1. Dependencies
1. Config
1. Backing services
1. Build, release, run
1. Processes
1. Port binding
1. Concurrency
1. Disposability
1. Dev/prod parity
1. Logs
1. Admin processes


text:
Frigate brings realtime object detection to any camera video feed supported by ffmpeg. More detailed docs are maintained [here](https://github.com/blakeblackshear/frigate).

## Required Dependencies
- MQTT: Frigate communicates via MQTT

## Recommended Configuration
- **Google Coral**: It is strongly recommended to use a Google Coral, but Frigate will fall back to CPU in the event one is not found. Offloading tensorflow to the Google Coral is an order of magnitude faster and will reduce your CPU load dramatically.
- **Resolution**: Choose a camera resolution where the smallest object you want to detect barely fits inside a 300x300px square. The model used by Frigate is trained on 300x300px images, so you will get worse performance and no improvement in accuracy by using a larger resolution since Frigate resizes the area where it is looking for objects to 300x300 anyway.
- **FPS**: 5 frames per second should be adequate. Higher frame rates will require more CPU usage without improving detections or accuracy.
- **Hardware Acceleration**: Make sure you configure the `hwaccel_args` for your hardware. They provide a significant reduction in CPU usage if they are available.

## Hardware Acceleration
Frigate works on Raspberry Pi 3b/4 and x86 machines. It is recommended to update your configuration to enable hardware accelerated decoding in ffmpeg. Depending on your system, these parameters may not be compatible.

Raspberry Pi 3/4 (32-bit OS):
```yaml
ffmpeg:
  hwaccel_args:
    - -c:v
    - h264_mmal
```

Raspberry Pi 3/4 (64-bit OS)
```yaml
ffmpeg:
  hwaccel_args:
    - -c:v
    - h264_v4l2m2m
```

Intel-based CPUs (<10th Generation) via Quicksync (https://trac.ffmpeg.org/wiki/Hardware/QuickSync)
```yaml
ffmpeg:
  hwaccel_args:
    - -hwaccel
    - vaapi
    - -hwaccel_device
    - /dev/dri/renderD128
    - -hwaccel_output_format
    - yuv420p
```

Intel-based CPUs (>=10th Generation) via Quicksync (https://trac.ffmpeg.org/wiki/Hardware/QuickSync)
**Note:** You also need to set `LIBVA_DRIVER_NAME=iHD` as an environment variable on the container.
```yaml
ffmpeg:
  hwaccel_args:
    - -hwaccel
    - vaapi
    - -hwaccel_device
    - /dev/dri/renderD128
```

## Support
Please [open an issue](https://github.com/blakeblackshear/frigate/issues/new/choose) if you need support.

repository: sheminasalam/frigate-hass-addons

repo_name: sheminasalam/frigate-hass-addons


text:
# Cloud Build Services

- [PhoneGap Build Support](#phonegap-build-support)
  - [Including the plugin](#including-the-plugin)
  - [Adding Resources](#adding-resources)
- [IntelXDK Support](#intelxdk-support)
- [Ionic Cloud Build](#ionic-cloud-build)

## PhoneGap Build Support

> PhoneGap Build now support version 1.9.0 of the plugin.

### Including the plugin

Including this plugin in a project that is built by PhoneGap Build is as easy as adding (replacing `123456789` with your own, that is):

```xml
<preference name="android-build-tool" value="gradle" />
<plugin name="phonegap-plugin-push" source="npm">
    <param name="SENDER_ID" value="123456789" />
</plugin>
```

into your app's `config.xml` file. PhoneGap Build will pick up the latest version of phonegap-plugin-push published on npm. If you want to specify a particular version of the plugin you can add the `spec` attribute to the `plugin` tag.

```xml
<preference name="android-build-tool" value="gradle" />
<plugin name="phonegap-plugin-push" spec="~1.4.5" source="npm" />
```

Note: version 1.3.0 of this plugin begins to use Gradle to install the Android Support Framework. Support for Gradle has recently been added to PhoneGap Build. Please read [this blog post](http://phonegap.com/blog/2015/09/28/android-using-gradle/) for more information.

### Adding resources

Because PhoneGap Build does not support running hooks if you want to include custom image or sounds you will need to use a *beta* feature to include these files.

#### Android

To add custom files, create a directory called `locales/android/` in the root of your PGB application zip / repo, and place your resource files there. The contents will be copied into the Android `res/` directory, and any nested sub-directory structures will persist. Here's an example of how these files will be compiled into your APK:

```
<www.zip>/locales/android/drawables/logo.png    --> <android_apk>/res/drawables/logo.png
<www.zip>/locales/android/raw/beep.mp3          --> <android_apk>/res/raw/beep.mp3
<www.zip>/locales/android/values-fr/strings.xml --> <android_apk>/res/values-fr/strings.xml
```

Existing directories will be merged, but at this time any individual files you include will overwrite their target if it exists.

## IntelXDK Support

1. Do pre-requisite setup on [the iOS Provisioning Portal](https://developer.apple.com/account/ios/identifier/bundle).  Refer to [this guide](https://www.raywenderlich.com/123862/push-notifications-tutorial) or Apple docs for detailed steps.
a. make a new App ID (you'll need to set this in Intel XDK config later)
b. enable push notifications
c. iOS Distribution cert: create (if needed), download and install (if needed), export as a .p12 (set and remember the password as you'll need this to import into Intel XDK later)
**NOTE**: Intel XDK does not support Development certs, so you MUST use your Distribution cert.
d. Make an AdHoc Provisioning Profile using your App ID from (1a) and your cert from (1c).  Make sure your test device is enabled.  Download and save with a name you will recognize. (you'll need to add this to your Intel XDK project later)
e. make a push cert, download it, install it, export it to .p12, convert it to .pem (this is for the push server that will send the notification - you'll need this later to test your Intel XDK app)

2. In Intel XDK, make a new Cordova CLI 5.4.1 project using the HTML5+Cordova Blank Template, then replace the contents of www with [the contents of www from the PhoneGap Push Template](https://github.com/phonegap/phonegap-template-push/tree/master/template_src/www).

3. Delete www/config.xml (optional? Intel XDK does not use config.xml)

4. Intel XDK Project Settings
a. set the iOS App ID to match the App ID from (1a)
b. (if needed) import your .p12 from (1c) - Account Settings->Developer Certificates->iOS, then select it as the Developer Certificate for the project
c. Select "adhoc" for Provisioning Profile
d. copy your provisioning profile from (1d) into www/, then click "Ad hoc Provisioning Profile" and select the profile
e. Add the latest version of phonegap-plugin-push as a "Third-Party Plugin" (at time of testing this was 1.6.4)
f. **After the plugin is added, you will need to edit plugins/phonegap-plugin-push/plugin.xml**.  Intel XDK 3357 does not support plugins with gradle references, so the gradle reference must be commented out (this will prevent this version of the plugin from working for Android but is needed for the iOS build to succeed):
`<!--framework src="push.gradle" custom="true" type="gradleReference" /-->`
A future version of Intel XDK will support gradle references.

5. XDK Build Tab
a. Enable iOS build (click the checkmark)
b. Unlock your iOS certificate (click the lock and enter the password from (1c))
c. click Start Builds
d. once the build completes, download and install the app

6. connect test device by USB and open XCode Devices window (probably could also use Safari Web Inspector + Cordova Console plugin) - start the app and a log message should be written into the console that looks like "Push Plugin register success: \<XXXXXXXX 19b101a3 71590c03 9ea7f446 50eb8409 19ac24bb c1ec1320 XXXXXXXX\>"

7. exit the app (close with home button then swipe it off the multitask view)

8. The angle brackets and everything between (from (5)) is the device token - copy it into a text file

9. Add the device token to your server and send a push notification
a. I used [phonegap-plugin-push/example/server/pushAPNS.rb](https://github.com/phonegap/phonegap-plugin-push/blob/master/example/server/pushAPNS.rb) for this
b. APNS.host = 'gateway.push.apple.com'
c. APNS.pem  = 'PGPush926Prod.pem' #path to your pem file from (1e)
d. device_token = '\<XXXXXXXX 19b101a3 71590c03 9ea7f446 50eb8409 19ac24bb c1ec1320 XXXXXXXX\>' #the device token from (7)
e. edit the alert message and badge number
f. you probably need to install the required gem (`gem install pushmeup`)
g. send the notification (`ruby pushAPNS.rb`)

10. See notification on device!

## Ionic Cloud Build

Users have reported issues with Ionic Cloud Build. Apparently there are some differences in the way variables are handled. If your app has an issue where the `PushNotification` object can't be found try the following.

1. Remove the inclusion of `phonegap-plugin-push` from config.xml. That is delete lines that look like this:

```
<plugin name="phonegap-plugin-push" spec="~1.9.1">
  <variable name="SENDER_ID" value="xxx"/>
</plugin>
```
2. Add the following lines into `package.json` in the `cordovaPlugins` array.

```
{
  "variables": {
    "SENDER_ID": "xxx"
  },
  "locator": "phonegap-plugin-push"
}
```

repository: fsek/app

gha_language: CSS

repo_name: fsek/app


text:
# Arkeytec Dashboard
A simple front-end admin application of a SaaS product which is used for viewing and managing the Architectural drawings generated by Artificial Intelligence algorithms designed at Arkeytec.

The easiest way to use Arkeytec Dashboard is to navigate to https://app.speckle.systems and login at your server.  Data will strictly be transferred between the client (the app in your browser) and your server.
 This works within private networks, amongst firewalls, etc. as long as you have a SSL certificate for your server (ie, non-https server adresses will not work).

## Fresh installation for a speckle server deployment
1. `cd ~/${your server install location}/plugins`
2. `git clone https://github.com/kartikderasari/arkeytec-dashboard.git`
3. `cd arkeytec-dashboard`
4. `npm install`
5. `npm run build`
6. `Restart your server, and navigate to its root address - done!`

### If you have previously installed the Arkeytec Dashboard frontend plugin, you should be able to just run the following commands from the plugin's folder

1. `git fetch`
2. `git pull`
3. `npm install - to make sure to pull along any potential new dependencies`
4. `npm run build`

## Development notes
To start a development server: `npm run dev`

To build for production: `npm run build`

## Like to contribute? Follow the guidelines!

- Fork the repository
- Navigate to your repository
- `git clone https://github.com/{yourusername}/arkeytec-dashboard.git`
- Add your contributions
- `git add .`
- `git commit -m "comment"`
- `git push`
- Navigate to **GitHub** and create a new **Pull Request**
- Wait back till your contributions are added :)

## Did you like the project?

`Don't forget to give it a ⭐`

repository: kartikderasari/arkeytec-dashboard

gha_language: Vue

repo_name: kartikderasari/arkeytec-dashboard


text:
# Probability [![Package][package-img]][package-url] [![Documentation][documentation-img]][documentation-url] [![Build][build-img]][build-url]

The package provides a probability-theory toolbox.

## Example

```rust
use probability::prelude::*;

let mut source = source::default();
let distribution = Uniform::new(0.0, 1.0);
let mut sampler = Independent(&distribution, &mut source);
let samples = sampler.take(10).collect::<Vec<_>>();
```

## Contribution

Your contribution is highly appreciated. Do not hesitate to open an issue or a
pull request. Note that any contribution submitted for inclusion in the project
will be licensed according to the terms given in [LICENSE.md](LICENSE.md).

[build-img]: https://travis-ci.org/stainless-steel/probability.svg?branch=master
[build-url]: https://travis-ci.org/stainless-steel/probability
[documentation-img]: https://docs.rs/probability/badge.svg
[documentation-url]: https://docs.rs/probability
[package-img]: https://img.shields.io/crates/v/probability.svg
[package-url]: https://crates.io/crates/probability


text:
# mtr-reporter

Command line tool to collect MTR report metrics into InfluxDB

Requires that the tool `mtr` is installed and on the PATH

```sh
Usage:

  -db string
    	InfluxDB DB (default "db0")
  -destination string
    	Destination to report on (default "<IP_ADDRESS>")
  -url string
    	InfluxDB reporting URL (default "http://localhost:8086")
  -verbose
    	Verbose logging
```

repository: tempusbreve/mtr-reporter

repo_name: tempusbreve/mtr-reporter


text:
rrStarter v3.1
===================

Hi you can use this litle script for init bootstrap your redux-react project watchout, this is not a framework but a 'classic base of redux project' with this script you can choose to init your project from scratch or if you use ES6 with babel, react, redux, express with nodejs, you will init all your project and install dependencies you have a webpack-config with this.

----------

## node version
- rrstarter work with latest node version you can run with old version but you should fix dependencies issues after rrstarter is currently maintened to use always last dependencies to get always best building performance.

- if you use old version of node just try to restore old dependencies version in package.json

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

HOW TO USE
-------------

Just run `sh install.sh`in your teminal after script ask you if you want to choose install with framework or from scratch

- After dependencies was installed add this lines to **package.json** object (you can add other script if you need)

	`"scripts": {
	    "start": "npm-run-all --parallel watch:server watch:build",
	    "watch:build": "webpack --config ./webpack.dev.js --watch",
	    "watch:server": "nodemon \"./dist/server.js\" --watch \"./dist\"",
	    "build:dev": "webpack --config ./webpack.dev.js",
	    "build:prod": "webpack --config ./webpack.prod.js",
	    "build:sw": "webpack --config ./webpack.sw.js",
	    "clear:dist": "rm -r ./dist",
	    "clear:upload": "rm -r ./uploads",
	    "clear": "rm -rf ./dist rm -rf ./uploads rm -rf ./node_modules"
	  }`

now you are ready to dev with nodejs react and redux fast no ?

- Just run `npm run start` this will create a **dist** folder with webpack and nodemon watching

or

- you can run `npm run build:prod` to create production build in **dist** after you just need to upload dist folder on production service you can set your env variable in **.env** file

## v3.1 features

v3.1 add some optimisations first its not use gulp anymore, **v3.1** reduce build time from ~**0.1ms** to ~**0.02ms** and reduce also install time
installing is more compatible with **windows ("emulate linux shell")** and v3.1 now is ready to start with minimal configuration **reducer ready** **react ready** **express server ready**
v3.1 add progressive wep app support with work box before build with service worker you need to install your own

note : rrStarter work always with with last version of webpack, react, redux, express

## License

this project is on MIT license mention and follow is apreciate

repository: InitialCrow/rrStarter

repo_name: InitialCrow/rrStarter


text:
# Balloon-Catheterization-GUI
GUI for the Balloon Catheterization capstone project

[![Build Status](https://travis-ci.org/omn0mn0m/transvenous_pacing_gui.svg?branch=master)](https://travis-ci.org/omn0mn0m/transvenous_pacing_gui)
[![Coverage Status](https://coveralls.io/repos/github/omn0mn0m/transvenous_pacing_gui/badge.svg?branch=master)](https://coveralls.io/github/omn0mn0m/transvenous_pacing_gui?branch=master)
[![PyPI](https://img.shields.io/pypi/v/transvenous-pacing-gui.svg)](https://pypi.org/project/transvenous-pacing-gui/)
[![GitHub](https://img.shields.io/github/license/omn0mn0m/transvenous_pacing_gui.svg)](https://github.com/omn0mn0m/transvenous_pacing_gui/blob/master/LICENSE)

# Usage
## Installation (Pre-Requisites)
The following software MUST be installed to use this project:

- [Python 3.7](https://www.python.org/downloads/)

## Installation (Using Command Line)
After this is installed, run `pip install transvenous_pacing_gui` in a command line to download the latest version of the GUI.

The GUI can be opened by running `transvenous_pacing_gui` in a command line.

## Installation (Using Scripts)
The same process above can be performed using the INSTALL.bat and RUN.bat scripts found in the [Releases](https://github.com/omn0mn0m/transvenous_pacing_gui/releases) page.

INSTALL.bat only needs to be run once to install the software. RUN.bat should be used each time to run the program.

# Modifying the Code
## (Pre-Requisites)
The following software MUST be installed to use this project:

- [Python 3.7](https://www.python.org/downloads/)

## Setup
To begin contributing to this project, download this project using either the [Download Zip](https://github.com/omn0mn0m/transvenous_pacing_gui/archive/master.zip) link or cloning the repository on GitHub.

All dependencies can be installed by running `pip install -r requirements.txt` from within the project directory. The code can be edited in whatever you'd like.


text:
# Bankruptcy Prediction System with Fuzzy Logic

We have taken 3 approaches in order to complete this assignment and this markdown file serves to explain their differences.

## 1. MATLAB GUI Fuzzy Toolbox

With MATLAB GUI Fuzzy Toolbox, we defined membership functions for all 6 variables in the `Membership Function Editor (⌘+2)`. Also, we defined 67 rules in the `Rule Viewer (⌘+5)` which are extracted from the paper, [The discovery of experts’ decision rules from qualitative bankruptcy data using genetic algorithms](https://www.sciencedirect.com/science/article/pii/S0957417403001027).

### To run
1. Make sure to point working directory to `fuzzy toolbox (MATLAB)` folder.
2. Launch MATLAB app, type `fuzzy` in the command window.
3. Click File, Import From File, select `FuzzyMiniProject.fis` from .

### To evaluate
1. Make sure to point working directory to `fuzzy toolbox (MATLAB)` folder.
2. Type `fis = readfis('FuzzyMiniProject')`
3. Our Fuzzy Inference System will accept 6 value (0-10) as input variable.
4. Type `fis.input.range` to view input range.
5. Type `output = evalfis([1;2;3;4;5;6], fis)`

## 2. MATLAB GENFIS3 (FCM)

Given separate sets of input and output data, `genfis3` generates a fuzzy inference system (FIS) using FCM clustering. With an appropriate set of numerical data, a FIS will be generated along with membership functions and rules.

However, upon further inspection of the data, we reckoned that our data (which is categorical data) tends to cluster really bad beyond counting duplicates. It is simply irrelevant to do fuzzy clustering on our dataset. As a result, our FCM produced a rather rigid calculation due to the nature of our data. We believe our work can be improved in the future by using an `Adaptive Neuro-Fuzzy Inference System (ANFIS)` as a classifier.

Regardless, it is possible to run our work with MATLAB and expect results. Data is being loaded and parsed as numerical data. 80% of the data is used for training and the rest is used for testing.

### To run
1. Make sure to point working directory to `genfis3 (MATLAB)` folder.
2. Open script by double clicking on `run.m` in the project directory menu.
3. Press `⌘+enter` to run the script. A `2x8` figure will be generated to visualize FIS surface and membership functions for both input and output variables.
4. Type `showrule(fis)` to show rules.
5. Type `fis.output.range` to view output range.
6. Type `output = evalfis([2;3;1;2;1;3], fis)` to generate output.

## 3. Rapidminer Neural Network

In Rapidminer, data type of attributes are converted into numerical data for neural network modeling and class attribute is set as `label`. `Cross-Validation` applied to train and estimate the statistical performance of neural network model generated.

repository: konyeha/Fuzzy-Logic-Mini-Project

repo_name: konyeha/Fuzzy-Logic-Mini-Project


text:
# The phfnote package

A handy LaTeX class for typesetting short notes and medium-length reports, full
of goodies to make it look just right.

The package phfnote provides basic formatting for short documents, such as notes
on a specific topic, short documentation, or quick memos. It aims to cover all
basic needs for such purposes: include a standard set of relevant packages, a
nice title which doesn't take up too much space, better page margin sizes, and
some basic styling to make the note look nicer. At the same time, it is highly
flexible and customizable.

# Documentation

Run `make sty` to generate the style file, `make pdf` to generate the package
documentation, and `make install` to install the package in your local texmf
tree. Run 'make' or 'make help' for more info.

# Author and License

(C) 2016-2021 Philippe Faist<EMAIL_ADDRESS>
License: [LaTeX project public license](http://www.ctan.org/license/lppl1.3),
version 1.3 or above

repository: phfaist/phfqitltx

gha_language: TeX

repo_name: phfaist/phfqitltx


text:
# parcel-frontend-skeleton

n0dag is GUI DAG builder for n0stack

## How to dev

- `yarn dev`: Start development server
- `yarn run check`: Try compile, lint, and format project
- `yarn build`: Generate `dist` for production
- `yarn deploy`: Deploy to netlify (need netlify account)

## Update dependencies

```
npx npm-check-updates -a
yarn install --force
yarn dev
```

## License

MIT

## Thanks

This application is developed based on github.com/mizdra/parcel-frontend-skeleton


text:
# \MessageApi

All URIs are relative to *https://api.us-south.assistant.watson.cloud.ibm.com*

Method | HTTP request | Description
------------- | ------------- | -------------
[**message**](MessageApi.md#message) | **post** /v2/assistants/{assistant_id}/sessions/{session_id}/message | Send user input to assistant (stateful)
[**message_stateless**](MessageApi.md#message_stateless) | **post** /v2/assistants/{assistant_id}/message | Send user input to assistant (stateless)

## message

> crate::models::MessageResponse message(assistant_id, session_id, version, request)
Send user input to assistant (stateful)

Send user input to an assistant and receive a response, with conversation state (including context data) stored by Watson Assistant for the duration of the session.

### Parameters

Name | Type | Description  | Required | Notes
------------- | ------------- | ------------- | ------------- | -------------
**assistant_id** | **String** | Unique identifier of the assistant. To find the assistant ID in the Watson Assistant user interface, open the assistant settings and click **API Details**. For information about creating assistants, see the [documentation](https://cloud.ibm.com/docs/assistant?topic=assistant-assistant-add#assistant-add-task).  **Note:** Currently, the v2 API does not support creating assistants. | [required] |
**session_id** | **String** | Unique identifier of the session. | [required] |
**version** | **String** | Release date of the API version you want to use. Specify dates in YYYY-MM-DD format. The current version is `2020-09-24`. | [required] |
**request** | Option<[**MessageRequest**](MessageRequest.md)> | The message to be sent. This includes the user's input, along with optional content such as intents and entities. |  |

### Return type

[**crate::models::MessageResponse**](MessageResponse.md)

### Authorization

[IAM](../README.md#IAM)

### HTTP request headers

- **Content-Type**: application/json
- **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

## message_stateless

> crate::models::MessageResponseStateless message_stateless(assistant_id, version, request)
Send user input to assistant (stateless)

Send user input to an assistant and receive a response, with conversation state (including context data) managed by your application.

### Parameters

Name | Type | Description  | Required | Notes
------------- | ------------- | ------------- | ------------- | -------------
**assistant_id** | **String** | Unique identifier of the assistant. To find the assistant ID in the Watson Assistant user interface, open the assistant settings and click **API Details**. For information about creating assistants, see the [documentation](https://cloud.ibm.com/docs/assistant?topic=assistant-assistant-add#assistant-add-task).  **Note:** Currently, the v2 API does not support creating assistants. | [required] |
**version** | **String** | Release date of the API version you want to use. Specify dates in YYYY-MM-DD format. The current version is `2020-09-24`. | [required] |
**request** | Option<[**MessageRequestStateless**](MessageRequestStateless.md)> | The message to be sent. This includes the user's input, context data, and optional content such as intents and entities. |  |

### Return type

[**crate::models::MessageResponseStateless**](MessageResponseStateless.md)

### Authorization

[IAM](../README.md#IAM)

### HTTP request headers

- **Content-Type**: application/json
- **Accept**: application/json

[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)

repository: gitter-badger/ibm-cloud-sdk

repo_name: gitter-badger/ibm-cloud-sdk


text:
# EncodedString

EncodedString is a wrapper for a string and a given encoding that handles operations on
strings with different encodings, invalid encodings, have no known conversion method,
or are otherwise incompatible, all without raising exceptions

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'encoded_string'
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install encoded_string

## Usage

Pick compatible encoding for two strings, if any:

```ruby
EncodedString.pick_encoding(str1, str2)
```

Wrap a string and make it safely accomodate the target encoding:

```ruby
string = "123".force_encoding(Encoding::UTF_8)
str = "abc".encode('ASCII-8BIT')
str = EncodedString.new(str, target_encoding = string.encoding)
str.source_encoding.to_s
str.split("\n")
str << "123"
str.to_s
```

## TL;DR

For a most cases, you can just use a function like:

```ruby
    def scrub_invalid_bytes(string, encoding: Encoding::UTF_8)
      return nil if string.nil?
      replace = "?"
      string = string.scrub(replace)
      string.encode(encoding)
    rescue Encoding::UndefinedConversionError, Encoding::InvalidByteSequenceError
      encode_unconvertable_bytes =  {
        :invalid => :replace,
        :undef   => :replace,
        :replace => replace
      }
      string.encode(encoding, encode_unconvertable_bytes)
    rescue Encoding::ConverterNotFoundError
      encode_no_converter = {
        :invalid => :replace,
        :replace => replace
      }

      string.dup.force_encoding(encoding).encode(encode_no_converter)
    end
```

## About

Encoding Exceptions:

```plain
Raised by Encoding and String methods:
  Encoding::UndefinedConversionError:
    when a transcoding operation fails
    if the String contains characters invalid for the target encoding
    e.g. "\x80".encode('UTF-8','ASCII-8BIT')
    vs "\x80".encode('UTF-8','ASCII-8BIT', undef: :replace, replace: '<undef>')
    # => '<undef>'
  Encoding::CompatibilityError
    when Encoding.compatibile?(str1, str2) is nil
    e.g. utf_16le_emoji_string.split("\n")
    e.g. valid_unicode_string.encode(utf8_encoding) << ascii_string
  Encoding::InvalidByteSequenceError:
    when the string being transcoded contains a byte invalid for
    either the source or target encoding
    e.g. "\x80".encode('UTF-8','US-ASCII')
    vs "\x80".encode('UTF-8','US-ASCII', invalid: :replace, replace: '<byte>')
    # => '<byte>'
  ArgumentError
    when operating on a string with invalid bytes
    e.g."\x80".split("\n")
  TypeError
    when a symbol is passed as an encoding
    Encoding.find(:"UTF-8")
    when calling force_encoding on an object
    that doesn't respond to #to_str

Raised by transcoding methods:
  Encoding::ConverterNotFoundError:
    when a named encoding does not correspond with a known converter
    e.g. 'abc'.force_encoding('UTF-8').encode('foo')
    or a converter path cannot be found
    e.g. "\x80".force_encoding('ASCII-8BIT').encode('Emacs-Mule')

Raised by byte <-> char conversions
  RangeError: out of char range
    e.g. the UTF-16LE emoji: 128169.chr
```

See [lib/encoded_string.rb](lib/encoded_string.rb) and
[spec/encoded_string_spec.rb](spec/encoded_string_spec.rb) for more information.

## Development

After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).

## Contributing

Bug reports and pull requests are welcome on GitHub at https://github.com/bf4/encoded_string. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.

## License

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


text:
[![Build Status](https://travis-ci.org/falsecz/beer-script.png?branch=master)](undefined)

                                      ____
                                     |  _ \
     .- ----------- -.               | |_) | ___  ___ _ __
    (  (.} {.} {.} }  )              |  _ < / _ \/ _ \ '__|
    |`-..________ ..-'|              | |_) |  __/  __/ |
    |                 |              |____/ \___|\___|_|
    |                 ;--.
    |                (__  \            _____           _       _
    |                 | )  )          / ____|         (_)     | |
    |                 |/  /          | (___   ___ _ __ _ _ __ | |_
    |                 (  /            \___ \ / __| '__| | '_ \| __|
    |                 |/              ____) | (__| |  | | |_) | |_
    |                 |              |_____/ \___|_|  |_| .__/ \__|
     `-.._________..-'                                  | |
                                                        |_|

  * support for @_private
  * support for @[$private + 'private']
  * support for goog.provide via --goog switch
  * include goog.dom as dom via --goog switch
  * auto include base class
  * support for enumeration
  * support for uses (mixins) [experimental]

```coffee
include goog.dom as dom
include builder.ui.Component as bui

class builder.ui.ColumnLayout extends goog.ui.Component
  constructor: ->
    dom.getElementByClass 'xxx'

enumeration builder.ui.ColumnLayout.ORIENTATION
   VERTICAL: 'vertical'
   HORIZONTAL: 'horizontal'

class builder.ui.Tree extends goog.ui.Component uses builder.mixins.repository

```

```javascript
goog.provide('builder.ui.ColumnLayout');
goog.provide('builder.ui.ColumnLayout.ORIENTATION');

goog.require('builder.ui.Component');
goog.require('goog.dom');

goog.scope(function () {
    var bui = builder.ui.Component;
    var dom = goog.dom;

    builder.ui.ColumnLayout = (function (_super) {
        var $private;

        __extends(ColumnLayout, _super);

        $private = '$builder_ui_ColumnLayout_';

        function ColumnLayout() {
            dom.getElementByClass('xxx');
        }

        return ColumnLayout;

    })(goog.ui.Component);

    builder.ui.ColumnLayout.ORIENTATION = {
        VERTICAL: 'vertical',
        HORIZONTAL: 'horizontal'
    };

}); // close goog.scope()
```

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

  CoffeeScript is a little language that compiles into JavaScript.

  Install Node.js, and then the CoffeeScript compiler:
  sudo bin/cake install

  Or, if you have the Node Package Manager installed:
  npm install -g coffee-script
  (Leave off the -g if you don't wish to install globally.)

  Execute a script:
  coffee /path/to/script.coffee

  Compile a script:
  coffee -c /path/to/script.coffee

  For documentation, usage, and examples, see:
  http://coffeescript.org/

  To suggest a feature, report a bug, or general discussion:
  http://github.com/jashkenas/coffee-script/issues/

  If you'd like to chat, drop by #coffeescript on Freenode IRC,
  or on webchat.freenode.net.

  The source repository:
  git://github.com/jashkenas/coffee-script.git

  All contributors are listed here:
  http://github.com/jashkenas/coffee-script/contributors

repository: falsecz/beer-script

repo_name: falsecz/beer-script