text:
# Push Messaging

{% hint style="warning" %}
This troubleshooting guide requires [Adobe Experience Platform Assurance](../../beta/project-griffon/). For more information about access and how to set up Assurance, see the [documentation](../../beta/project-griffon/).
{% endhint %}

When implementing push messaging via the Adobe Experience Platform Mobile SDK, you can validate the client-side implementation by verifying that you completed the following steps:

1. [Pass the device's push token to the SDK](troubleshooting-push.md#pass-the-push-identifier-to-the-sdk).
2. [Verify push token sync with the Experience Cloud Identity service](troubleshooting-push.md#validate-push-token-sync-with-the-experience-cloud-identity-service).
3. [Ensure user opt in for push in Adobe Analytics](troubleshooting-push.md#ensure-user-opt-in-for-push-in-adobe-analytics).
4. [Confirm user ID is correctly set \(and is same from steps 2 and 3, above](troubleshooting-push.md#confirm-that-the-user-id-is-correctly-set).

## Pass the Push Identifier to the SDK

The `setPushIdentifier` API sets the device token for push notifications in the SDK. This results in a few network calls made to the requisite Adobe servers to associate the user with the push token.

{% hint style="warning" %}
If SDK privacy status is`optedout`, the push identifier will not be set.
{% endhint %}

### setPushIdentifier

{% tabs %}
{% tab title="Android" %}
### Java

#### Syntax

```java
public static void setPushIdentifier(final String pushIdentifier);
```

#### Example

```java
// retrieve the token from either GCM or FCM, and pass it to the SDK
MobileCore.setPushIdentifier(token);
```
{% endtab %}

{% tab title="iOS" %}
### Objective C

#### Syntax

```objectivec
+ (void) setPushIdentifier: (nullable NSData*) deviceToken;
```

#### Example

```objectivec
// pass the deviceToken that the APNS has assigned to the device
[ACPCore setPushIdentifier:deviceToken];
```

### Swift

#### Syntax

```swift
Void setPushIdentifier(deviceToken: Data?)
```

#### Example

```swift
// pass the deviceToken that the APNS has assigned to the device
ACPCore.setPushIdentifier(deviceToken)
```
{% endtab %}

{% tab title="React Native" %}
### Javascript

#### Example

```jsx
ACPCore.setPushIdentifier("pushIdentifier");
```
{% endtab %}
{% endtabs %}

## Verify push token sync with the Experience Cloud Identity service

Launch your app with the device connected to an [Adobe Experience Platform Assurance session](../../beta/project-griffon/).

In the list of events, verify that you have an event with type `SetPushIdentifier`. In the details panel on the right, verify the value of the push token for this device. The value in `pushIdentifier` is the same value that is sent to the Adobe servers.

![](../../.gitbook/assets/push_token_to_identity.png)

## Ensure user opt-in for push in Adobe Analytics

Launch your app with the device connected to an [Assurance session](../../beta/project-griffon/).

In the resulting list of events, verify that you have an event with type `AnalyticsForIdentityRequest`. In the details panel on the right, you can see that there is a value that was sent to Analytics that opts this user in to receive push notifications.

![](../../.gitbook/assets/push_analytics_optin.png)

## Confirm that the user ID is correctly set

Launch your app with the device connected to an [Adobe Experience Platform Assurance session](../../beta/project-griffon/).

In the list of events, verify that you have an event with type `UPDATED_IDENTITY_RESPONSE`. In the details panel on the right, confirm that the following values are correct:

* The value for `pushidentifier` should match the value that was sent in step 2 above.
* The value for `mid` should match the value for `mid` that is sent to Analytics.  If you are using a [custom visitor identifier](../../using-mobile-extensions/adobe-analytics/analytics-api-reference.md#setidentifier), this payload should also contain a `vid` variable with a value that matches the value that was used to identify this user.

![](../../.gitbook/assets/push_identities.png)

After completing these steps, your app is correctly configured and is ready to send push messages via the SDK and Adobe.


text:
---
title: 'Chronic Recoverable Neuropixels in Mice'
date: 2023-03-29
authors: ['admin']
layout: post
categories: ['Animal electrophysiology','Hardware','Behaviour']
tags: ['Animal electrophysiology','Hardware','Behaviour']
links:
- name: Follow
  url: https://twitter.com/@emilyaeryjones
  icon_pack: fab
  icon: twitter

---
This protocol collection explains how to build a low-cost, lightweight system to implant 1 Neuropixels 1.0 probe or 2 Neuropixels 2.0 probes into mice, record during freely moving behavior, then recover the probes for future use. The design is <3g for a one probe and <4g for two probes, allows headfixed or freely moving recordings, and includes a headstage holder with tracking LEDs and connection to a counterweight to encourage running. By 5 days post-op, cell yields are steady for weeks and mice are able to 60cm/s in a 1m arena. Unlike other currently available designs, probes are independently insertable, so you can set custom positions, depths, and angles for each of the 2 probes.

This complete protocol collection includes all necessary build files, code, and lists of parts and equipment. It is intended for scientists with familiarity with stereotactic surgery, but requires no other prior knowledge.

Protocols include:
* Assembly: how to 3D print components, sharpen, solder, and test the probe, and prepare components for surgery.
* Implant surgery
* Explant surgery
* Building a SpikeGLX rig with camera: How to build a Neuropixels recording system using a National Instruments acquisition system and SpikeGLX software, from parts acquisition through your first recording, and how to integrate a camera, including code and wiring to record and synchronize video frames.
* Freely moving recording: How to build enclosures for spatial tasks, construct a frame to mount the enclosures and related hardware, and wire and code an Arduino to operate poke detectors, pinch valves to dispense reward, and floor-mounted doors. How these procedures can be used specifically to build an X-maze for mice. How to integrate recording by building a headfixation apparatus for easy headstage attachment and a pulley-operated counterweight to counteract the headstage weight and enable easier running.
## Project Author(s)
Emily A. Aery Jones
## Project Links
dx.doi.org/10.17504/protocols.io.e6nvwjo87lmk/v1
## Project Video
https://content.protocols.io/files/kh8rbqrq7.mp4
***
This post was automatically generated by
Emily A. Aery Jones
***

license: MIT

branch_name: refs/heads/main

extension: md

gha_language: Jupyter Notebook

gha_license_id: MIT

license_type: permissive


text:
# Future of Eryn

There are some topics not covered and not supported yet. Feel free to [open an Issue](https://github.com/caiangums/react-native-template-eryn/issues) or [create a PR](https://github.com/caiangums/react-native-template-eryn/pulls) with improvments such as:

- Test Support, if possible with [React Native Testing Library](https://callstack.github.io/react-native-testing-library/)
- Examples of usage

repository: caiangums/react-native-template-eryn

gha_language: JavaScript

repo_name: caiangums/react-native-template-eryn


text:
# PropSimEX

PropSim integrated executable source code. Runs a liquid rocket engine simulator.
To run on Windows systems:

```properties
./PropSimIntegrated.exe PropSimInput.json
```

To run on macOS/Linux systems:

```properties
./run_PropSimIntegrated.sh $MCR_PATH/v99 PropSimInput.json
```

Here, $MCR_PATH is the path to your MATLAB Complier Runtime (usually somewhere under /usr/local/).

## MATLAB Compiler

To generate an executable (.exe file for Windows and .sh file for macOS/Linux) from this source code, run

```matlab
mcc -m PropSimIntegrated.m -o PropSimIntegrated
```

in the MATALB command window. Once the compilation is complete, a `PropSimIntegrated.exe` or `PropSimIntegrated.sh` is generated, which can be run via a command prompt. These executables are also called from DesignLiquidEngine. Here, the `-o` option specifies the name of the final executable.

## Outputs

`PropSimIntegrated` outputs a MATLAB data file called `PropSimOutput.mat` in the `./helpers` directory. A copy is made and moved to the current case folder (under `./helpers/case-files/[your-case-name]`). There, the data file is read by DesignLiquidEngine and plotted given that the runtime option (specified in `./config.yaml`) is set to `true`.

gha_language: Fortran


text:
---
layout: default
---

# 1998-11-05 - No Subject

## Header Data

From: Mixmaster<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: b9b78bf484bd61e08ea6814dbf9c72ff18e7cde34c2bce5567d348f7831b8171

Message ID: \<99ebb21979319a23b4f5dafb9ef3cf83@anonymous\>

Reply To: _N/A_

UTC Datetime: 1998-11-05 23:37:19 UTC

Raw Date: Fri, 6 Nov 1998 07:37:19 +0800

## Raw message

```
{% raw  %}From: Mixmaster<EMAIL_ADDRESS>Date: Fri, 6 Nov 1998 07:37:19 +0800
To<EMAIL_ADDRESS>Subject: No Subject
Message-ID: <99ebb21979319a23b4f5dafb9ef3cf83@anonymous>
MIME-Version: 1.0
Content-Type: text/plain

Re voting for politicos:  just received this spam...
--------- Begin forwarded message ----------
Subject: Psst.....
Date: Wed, 4 Nov 1998 09:31:39 -0500
Message-ID:
<EMAIL_ADDRESS>
>>>
>>>>When John Glenn returns from space, everybody dress in Ape Suits.
>>>>
>>>>Pass it on.
>>>>

--------- End forwarded message ----------

{% endraw %}
```

## Thread

+ Return to [November 1998](/archive/1998/11)

+ Return to "[Mixmaster <mixmaster@remail.obscura.com>](/authors/mixmaster_mixmaster_at_remail_obscura_com_)"

+ 1998-11-05 (Fri, 6 Nov 1998 07:37:19 +0800) - No Subject - _Mixmaster<EMAIL_ADDRESS>

branch_name: refs/heads/master


text:
# How to simplify your statistical reports using R Markdown

## Introduction

This course will be a practical introduction on how to create a reproducible workflow using R Markdown. The participants will see how they can create tidy reports merging R code and their conclusions. There will be data analysis exercises where reports will be written by the participants, showing them how to create their own reports.

This short course was a part of the scientific program of the [Second Conference on Statistics and Data Science](http://www.csds2019.ime.ufba.br/), on 18-20 November 2019.

You can cite this work using

    @software{Nunes2019,
      author       = {Marcus Nunes},
      title        = {{mnunes/2nd-csds: How to simplify your statistical
                   reports using R Markdown}},
      month        = nov,
      year         = 2019,
      publisher    = {Zenodo},
      version      = {v1.2},
      doi          = {10.5281/zenodo.3549055},
      url          = {https://doi.org/10.5281/zenodo.3549055}
    }

or

> Marcus A. Nunes. (2019, November 20). mnunes/2nd-csds: How to simplify your statistical reports using R Markdown (Version v1.2). Zenodo. http://doi.org/10.5281/zenodo.3549055

## Computer setup

You need to install the following software:

- `R`: [https://cran.r-project.org/](https://cran.r-project.org/)
- RStudio: [https://www.rstudio.com/products/rstudio/download/](https://www.rstudio.com/products/rstudio/download/)
- If you're running Windows, you need to install [Rtools](https://cran.r-project.org/bin/windows/Rtools/)
- Some packages either running `source("https://raw.githubusercontent.com/mnunes/2nd-csds/master/setup.R")` inside RStudio or clicking on [https://github.com/mnunes/2nd-csds/blob/master/setup.R](https://github.com/mnunes/2nd-csds/blob/master/setup.R) and copying and pasting its contents

<hr >

This short course was prepared by [Marcus Nunes](https://marcusnunes.me), Assistant Professor at Department of Statistics - UFRN.


text:
# FOTWindow

A NSWindow subclass that mimics the look and behavior of Quick Time X

## Usage

To use It, just replace your NSWindow with a FOTWindow. This can be done in your xib file (see example project)

![screenshot](https://raw.github.com/insidegui/FOTWindow/master/FOTWindow.gif)

repository: fzaleagu/FOTWindow

repo_name: fzaleagu/FOTWindow


text:
# Logster - login/register-page-app

> Simple login/register-page-app created with React js.

Logster is a React app that has a Login, Register and Reset password features. This is just the Front-end of the app, no Back-end.

## Table of contents
* [Functionalities](#functionalities)
* [Technologies](#technologies)
* [Live App](#live-app)
* [Packages & Libraries](#packages-&-libraries)
* [Contributing](#contributing)
* [Support](#support)
* [Final Words](#final-words)
* [License](#license)

## Functionalities

* Login with username and password
* Create an account
* Reset password

## Technologies

* React js
* HTML5
* CSS3

## Live App

To view and test the app you can visit this [link](https://logsterapp.netlify.com/).

## Packages & Libraries

* [react-router-dom](https://www.npmjs.com/package/react-router-dom)

## Contributing

Pull requests are welcome. Please feel free to submit an issue first to discuss what you would like to change.

The process to start is simple, just make sure you have [Node js](https://nodejs.org/en/) installed in your computer.

First you need to go to project's main directory which contains package.json file

```bash
    git clone [Repository]

    cd [Repository-Directory]

    npm install

    npm start
```
or
```bash
    git clone [Repository]

    cd [Repository-Directory]

    yarn install

    yarn start
```
.. happy Coding..!!

## Support

Reach out to me at one of the following places!

- Website at `izemspot.netlify.com`
- Gmail <a<EMAIL_ADDRESS><EMAIL_ADDRESS>

## Final Words

If you like the app, please give it a star. It will mean a lot for me :)

## License

- **[MIT license](http://opensource.org/licenses/mit-license.php)**
- Copyright 2019 © IZEMSPOT.

repository: faizazafar/react-login-register-page

repo_name: faizazafar/react-login-register-page


text:
# EasyScreenshot
Tool to take easily screenshots of whole desktop or parts of it.

###Version
02-May-2015

###Installation
No installation required

###Usage
After starting the application press ALT+SHIFT+F3 to take a photo of whole screen or ALT+SHIFT+F4 to take photo part of it. Photos getting saved on desktop.

###License
MIT

repository: Demiveo/EasyScreenshot

repo_name: Demiveo/EasyScreenshot


text:
**R. Lloyd**. Lincoln. May 2021.

---

There's something i've always wondered about this 'internet of things', 'thing'. How do you make one of these Things? What goes into them? I've used open source firmwares like [Tasmota](https://tasmota.github.io/docs/) on a [Sonoff Device](https://sonoff.tech/products/) for home automation and those things are basically an esp8266 and a mains relay. What we'll mainly be talking about here is the interface to things. There might be a sensor or servo here and there, but i'm more wanting to know about the UI for normal people and the websocket server backend so we're ready for the computer scientists.

Well, here I am to share what I learn on this rambling journey into the Thingiv... dammit, that's taken... into the World of the Things... yeah, it's not as good.

(Hello, Future Rob here. It's sunday and I don't want to reformat the whole thing, so this document has two sections. I'd suggest at least reading through and following the install steps from the  tutorial I copied out the stepos for, that should set you up for the fun stuff at the end).

# Lets see how other people suggest doing it....
## The World of the Things

First of all, I'm going to look at this tutorial, because it's using bootstrap as the css and js bit... so I should get the gist of it for when I want to use p5.js and do some sort of cool trippy graphics shit too.. that's a point, what other libraries can you serve? Oh yeah, most importantly, this is all based on the [esp8266](https://tttapa.github.io/ESP8266/Chap01%20-%20ESP8266.html). Hopefully using [SPIFFS](https://tttapa.github.io/ESP8266/Chap11%20-%20SPIFFS.html)... i don't know, I've not got that far yet... I should also say at this point, If you haven't installed the [Arduino IDE](https://www.arduino.cc/en/software), you'll need to do that and I'd suggest google is your friend throughout this whole process.

First tutorial I looked at:

[How to create a beautiful Web Interface for projects ESP8266 / ESP32 with Bootstrap](https://diyprojects.io/bootstrap-create-beautiful-web-interface-projects-esp8266/#.YJG5IqEo-Uk)

Yeah.. I didn't follow that tutorial, I just looked at it. Follow that tutorial if you're coming at this from knowing how to use bootstrap. The arduino bit is just copypasta.

I want to understand how it all works so we can fiddle with things. The search continues...

This looks better:

[ESP8266 Web Server using SPIFFS (SPI Flash File System) – NodeMCU](https://randomnerdtutorials.com/esp8266-web-server-spiffs-nodemcu/)

Ok, this looks good

![System Overview](./images/example-system.bmp)

That will make you:

## 1. Install ESP8266 Board in Arduino IDE

    We’ll program the ESP8266 using Arduino IDE, so you must have the ESP8266 add-on installed. Follow the next tutorial to install it:

    [Install ESP8266 Board in Arduino IDE (Windows, Mac OS X, Linux)](https://randomnerdtutorials.com/how-to-install-esp8266-board-arduino-ide/) .... but you should have done this before now

Holdup... how about I save you the trouble. Go to the github repo:

https://github.com/esp8266/arduino-esp8266fs-plugin

Follow the instructions to install it the extra stuff in the arduino IDE

## 2. Filesystem Uploader Plugin

To upload files to the ESP8266 SPI Flash Filesystem (SPIFFS), we’ll use the Filesystem Uploader Plugin. Install the plugin in your Arduino IDE:

[Install ESP8266 Filesystem Uploader in Arduino IDE](https://randomnerdtutorials.com/install-esp8266-filesystem-uploader-arduino-ide/)

## 3. Installing Libraries

Apparently, one of the easiest ways to build a web server using files from the filesystem is using the [ESPAsyncWebServer](https://github.com/me-no-dev/ESPAsyncWebServer) library.

## 4. Installing the ESPAsyncWebServer library

This library is not available to download through the Arduino IDE libraries manager. So, you need to follow the next steps to install the library:

[Click here to download the ESPAsyncWebServer library.](https://github.com/me-no-dev/ESPAsyncWebServer/archive/master.zip) You should have a .zip folder in your Downloads folder
Unzip the .zip folder and you should get ESPAsyncWebServer-master folder
Rename your folder from ESPAsyncWebServer-master to ESPAsyncWebServer
Move the ESPAsyncWebServer folder to your Arduino IDE installation libraries folder

Alternatively, you can go to Sketch > Include Library > .zip Library and select the previously downloaded library.

## 5. Installing the ESPAsyncTCP

https://github.com/me-no-dev/ESPAsyncTCP

https://github.com/me-no-dev/ESPAsyncTCP/archive/refs/heads/master.zip

The ESPAsyncWebServer library also needs the ESPAsyncTCP library to operate properly. Follow the next steps to install the ESPAsyncTCP library:

    Click here to download the ESPAsyncTCP library. You should have a .zip folder in your Downloads folder
    Unzip the .zip folder and you should get ESPAsyncTCP-master folder
    Rename your folder from ESPAsyncTCP-master to ESPAsyncTCP
    Move the ESPAsyncTCP folder to your Arduino IDE installation libraries folder
    Finally, re-open your Arduino IDE

Alternatively, you can go to Sketch > Include Library > .zip Library and select the previously downloaded library.

# And now the fun begins! Try it for ourselves!

With all of that done, it's time to implement our own use. Fot this I am going to use the p5.js library for multiple reasons:

- It's a great library, based on [Processing3](https://www.processing.org), allowing the relatively simple generation of interactive 'sketches'.
- If you get stuck, you can check out 'The Coding Train' on Youtube.
- There is an [online editor](https://editor.p5js.org)
- We can simply copy the code from the 'data' folder associated with the sketch.

## 1. Find the code and open it in the Arduino IDE

I've prepared this github repository with a p5 version of Conways 'Game of life'. You're reading this document on it, so I'll assume you have downloaded it. If you're serious about getting into all of this, I'd suggest installing git and then doing:

    git clone https://github.com/rwlloyd/p5-javascript-webserver.git

## 2. Update the wifi details in the sketch.

Before you upload the sketch to your microcontroller, don't forget to change your wifi details in the .ino file, you were nearly all trying to connect to my wifi...

![Wifi Details](./images/network.png)

## 3. Upload the Arduino Sketch

To upload code to the esp8266, simply plug it in over usb and upload the sketch through the ArduinoIDE as you were shown in the things you googled earlier.

Once the upload is complete, verify everything has worked by opening the serial monitor and get something that looks like this;

![Successful upload](./images/success.png)

Obviously, or maybe not, your IP address is probably different to mine, but if you want to do a quick check it's actually there on your network, try:

    ping <IP_ADDRESS>

This should get a response. That's all we're worried about right now. It won't do anything in a webbrowser, apart from maybe throw an error... We need some files to host. And with that in mind;

## 4. Upload to SPIFFS

This is done by simply using the tool that was installed during the tutorial above. It will look for a folder called 'data' in the current directory and then upload whatever is in it until the SPI flash memory on the microcontroller is full. 'FULL' full is bad. Also, theres a max filesystem size of 4MB if you don't want to be able to do OTA flashing and other fancy stuff.... apparently.

(I ran into trouble because i didn't have the correct board settings, namely the serial port I'd selected was wrong. The IDE didn't help me identify this at all. It just said 'no')

![SPIFFSTool](./images/SPIFFSTool.png)

## 5. Play the 'Game of Life'

If you now go to the IP address that has recently appeared on you network, you should be presented with something that looks like this;

![It's just a game](./images/conway.png)

I don't remember exactly where I got the sketch from. But it probably came from following [Coding Challenge #85: The Game of Life](https://www.youtube.com/watch?v=FWSR_7kZuYg). I would encourage you to explore this channel if you're new to p5.js and coding in general.

# The End of the Beginning

Thank you for reading all the way to the bottom of this document. I hope it was helpful. Now go and make something with your new found 'thing' skills. If youhave any comments, questions or issues, pull requests etc, please do those through the github repository. (It will help me learn how to use them)


text:
Trained models for use with Tensorflow.JS

You can load each of them using code like:

```javascript

tf.loadLayersModel(`/models/anger/model.json`).then(model => /* do something with it */)

```

And get predictions from LASER sentence embeddings with:

```javascript

 model.predict(tf.tensor(embeddings)).data().then(prob => /* do something with the probability */)

 ```

 For more reference see https://www.tensorflow.org/js


text:
# Polymath ST20 Templates

In order to streamline the process of issuing a compliant security token, and
leveraging the decentralized and open nature of blockchains, the concept of a
security token compliance template is used.

Compliance templates allow issuers to easily apply transfer restrictions and a
KYC provider to ST20 tokens. The main function of templates are to specify the
jurisdictions and accreditation status that the investor must be set to (by a
the KYC provider on the template) to hold the security token. If they do not
meet the template requirements, any transfer of security tokens to their address
will fail. They can also store a hash of documents related to the offering
requirements on chain.

## Who creates templates?

Delegates will create templates, and it is likely that the community will steer
towards a few templates based off recommendations by industry leaders. It is
also possible that individual hosts create their own templates that fit within
their existing processes.

## What is in a template?

owner - The delegate who is claiming the template meets regulatory requirements
by creating the template

offeringType - A string description i.e. 506b

issuerJurisdiction - The issuers ISO3166 jurisdiction

allowedJurisdiction - A mapping of allowed ISO3166 jurisdictions

allowedRoles - A mapping of allowed roles (uint)

accredited - Whether or not the investor must be accredited

KYC - The KYC providers address

details - A hash of compliance documents for the security offering

finalized - Allows the owner to make edits to the template and finalize it when
ready

expires - When the template expires and can no longer be applied to security
tokens

fee - The fee the delegate would like for their services

quorum - The percent of initial investors in the security token to freeze
service fee

vestingPeriod - How long the delegate is willing to lockup their service fees

repository: sksshopee/polymath-core

repo_name: sksshopee/polymath-core


text:
HLS-Stream-Creator
==================

Introduction
-------------

HLS-Stream-Creator is a simple BASH Script designed to take a media file, segment it and create an M3U8 playlist for serving using HLS.
There are numerous tools out there which are far better suited to the task, and offer many more options. This project only exists because I was asked to look
into HTTP Live Streaming in depth, so after reading the [IETF Draft](http://tools.ietf.org/html/draft-pantos-http-live-streaming-11 "HLS on IETF") I figured I'd start with the basics by creating a script to encode arbitrary video into a VOD style HLS feed.

Usage
------

Usage is incredibly simple

```
./HLS-Stream-Creator.sh inputfile segmentlength(seconds) [outputdir='./output']
```

So to split a video file called *example.avi* into segments of 10 seconds, we'd run

```
./HLS-Stream-Creator.sh example.avi 10
```

Output
-------

As of version 1, the HLS resources will be output to the directory *output*. These will consist of video segments encoded in H.264 with MP3 audio (should be AAC really, but I'd compiled *ffmpeg* without) and an m3u8 file in the format

>\#EXTM3U
>\#EXT-X-MEDIA-SEQUENCE:0
>\#EXT-X-VERSION:3
>\#EXT-X-TARGETDURATION:10
>\#EXTINF:10, no desc
>example_001.ts
>\#EXTINF:10, no desc
>example_002.ts
>\#EXTINF:10, no desc
>example_003.ts
>\#EXTINF:5, no desc
>example_004.ts
>\#EXT-X-ENDLIST

Using a Specific FFMPEG binary
-------------------------------

There may be occasions where you don't want to use the *ffmpeg* that appears in PATH. At the top of the script, the ffmpeg command is defined, so change this to suit your needs

```
FFMPEG='/path/to/different/ffmpeg'
```

License
--------

HLS-Stream-Creator is licensed under the [BSD 3 Clause License](http://opensource.org/licenses/BSD-3-Clause) and is Copyright (C) 2013 [Ben Tasker](http://www.bentasker.co.uk)

repository: ndamiens/HLS-Stream-Creator

gha_language: Shell

repo_name: ndamiens/HLS-Stream-Creator


text:
Blueprint Sorting
=================

Overview
--------

BlueprintSorting is a plugin for [Unreal Engine 4](https://www.unrealengine.com/) that allows arrays to be sorted with functions in-place in blueprints.

For examples check out the [Blueprint Sorting Examples repository](https://github.com/sh54/BlueprintSortingExamples).

One custom node is included in this plugin along with a few helpers.

![Image of sorting](Images/SortingExample.png)

Note that the current sorting algorithm is highly inefficient and will be replaced when I need it.
It will work fine on small arrays but expect slowness if a thousand element array is to be sorted.

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

### Integration

There are a couple of different ways to integrate this plugin into your project. You can include it in your fork of the UE4 engine or you can include it in a single UE4 code-based project if you like.

#### In your engine

This method includes the plugin in your fork of the UE4 engine. It allows you to use the plugin in either code or blueprint-based projects that are created with your fork of the engine. It assumes you have already cloned the UE4 engine to a directory on your machine.

1. Clone this repo to a subfolder of your engine called /Engine/Plugins/BlueprintSorting. Optionally, you can add it as a submodule.
2. Run the GenerateProjectFiles script in the Engine root.
3. Open your engine project file and build the editor.

#### In your code project

This method includes the plugin in a single code-based project. This can be done on any code-based project that is created using the Github source engine or the one provided by Epic via the launcher.

1. Clone this repo to a subfolder in your project called /Plugins/BlueprintSorting.
2. Open your project. You will be prompted to build missing modules.
3. Select Yes to rebuild now.

### Enable the Plugin

Ensure that the plugin is enabled:

1. In the editor, select Plugins from the Window menu.
2. Search for the plugin called Blueprint Sorting. It's in the Blueprints category.
3. Check the Enabled checkbox on the plugin. You may have to restart the editor after this step.

![EnableThePlugin](Images/EnableThePlugin.png)

Sort Array node
---------------

### Initial state

![Image of sort array initial state](Images/SortArrayInitialState.png)

This is how a sort array node starts off.

The *Sort Direction* input pin decides if the array should be sorted from lowest to highest or highest to lowest.
It takes an enum of the type `ESortDirection` which has the members `Ascending` and `Descending`.
This enum is defined in C++ and is included in this plugin.

The *Array* input pin initially accepts any type of array. The array it is connected to will get sorted in-place when this *Sort Array* node is triggered.

The ordering event input pin only appears when the array input pin is connected.

### State when connected to an array

When the node is connected to an array the ordering event input pin will appear if a relevant event signature can be found.
It would be nice if this was not required.
There must exist some event dispatcher anywhere in the project that has the inputs *type of array*, *type of array*, *Ordering Result*.
e.g. if an array of floats is to be sorted then there needs to be an event dispatcher somewhere with the signature *float*, *float*, *Ordering Result*.

![Image of float event dispatcher](Images/FloatOrderingEventDispatcherSignature.png)

If such an event dispatcher is not found then an ordering event pin will not be added to the node.
If the node has its exec pin connected to something and the relevant blueprint is compiled then errors will be reported in the *Compiler Results* window.

![Image of compiler errors](Images/CompilerErrors.png)

If a relevant event dispatcher is found then the ordering event pin will be created.

Note that the event dispatcher is just there as a dummy. It is not recommended to used them for anything else aside from providing signatures.
It is recommended to dump all the event dispatchers needed in one place for tidyness.
If some dummy object is used to store all the signatures and it is not actually used then ensure that is gets cooked.

### The ordering event pin

The ordering event pin must be connected to some event (or function via the *Create Event* node).
The connected event must determine if one items is greater than, equal to, or less than some other item.
Normally some ordering function would be expected to return a result stating if one item is larger than the other.
However events only have inputs and not outputs thus an `Ordering Result` object is supplied and the event is expected to set its `Result` variable to something.

#### Order by custom event

One way to provide an ordering event is to connect the *Sort Array* node to a *Custom Event* node.

![Image of connecting a sort array to a custom event](Images/ConnectSortArrayToCustomEvent.png)

Note that support for this depends on the blueprint type. A blueprint function library does not support this.

The event will have inputs of item A, item B and the ordering result.
The event must compare item A to item B and set the variable *Result* of the input ordering result to
*Greater Than* if item A is greater than item B, *Equal* if item A is equal to item B, or *Less Than* if item A is less than item B.
It is not defined what will happen if the *Result* variable is not set.

#### Order by create event

The other way to provide an ordering event is to connect the *Sort Array* node to a *Create Event* node.

![Image of connecting a sort array to a create event](Images/ConnectSortArrayToCreateEvent.png)

This allows some function to be used. This function can either be in the same blueprint or supplied by another object.

![Image of sorting an array with a function](Images/SortingExampleUsingFunction.png)

Internal details
----------------

The base functionality for the node is provided by the class `UBPNode_BaseSortArray`.
The actual sort array node is the class `UBPNode_SortArray`.
If other sort algorithms are added (e.g. anything other than bubble sort) then other sort array node classes may be created.

The tricky issue is that the sort algorithm must be supplied by building up a series of statements for the node.
If there is an alternative I would like to know it!
As a proof of concept the [bubble sort algorithm](https://en.wikipedia.org/wiki/Bubble_sort) has been implemented since this was easiest to write.
When needed I will add a [quicksort](https://en.wikipedia.org/wiki/Quicksort) implementation.

The node is compiled with the relevant subclass of `FNodeHandlingFunctor`.
The base functionality is provided by class `BPCHandler_BaseSortArray`.
The compile of the sort algorithm is supplied by a subclass of `BPCHandler_BaseSortArray`.
As of now only bubble sort has been implemented and this can be found in `BPCHandler_BubbleSortArray`.

The `UBlueprintSortingHelperLibrary` helper class contains various functions to help the sorting algorithm.


text:
---
title: date package
description: >

menu:
  flux_0_x_ref:
    name: date
    parent: experimental
    identifier: experimental/date
weight: 21
---

<!------------------------------------------------------------------------------

IMPORTANT: This page was generated from comments in the Flux source code. Any
edits made directly to this page will be overwritten the next time the
documentation is generated.

To make updates to this documentation, update the comments above the package
declaration in the Flux source code:

https://github.com/influxdata/flux/blob/master/stdlib/experimental/date/date.flux

Contributing to Flux: https://github.com/influxdata/flux#contributing
Fluxdoc syntax: https://github.com/influxdata/flux/blob/master/docs/fluxdoc.md

------------------------------------------------------------------------------->

## Packages

{{< children show="sections" >}}


text:
<!-- markdownlint-disable-file MD013 -->
<!-- markdownlint-disable-file MD033 -->
<!-- markdownlint-disable-file MD034 -->

# Description

A scaffold generator to create a [spring boot](https://spring.io/projects/spring-boot) enviroment

Inspired by https://start.spring.io

This formula generate a scaffold project using spring boot and dependencies that you to choose

## Command

```bash
rit scaffold generate spring-starter
```

## Requirements

- [Golang installed](https://golang.org/doc/install)

## Demonstration

<img src="https://github.com/ZupIT/ritchie-formulas/blob/main/scaffold/generate/spring-starter/demo.gif">

repository: patrickfarias/ritchie-formulas

repo_name: patrickfarias/ritchie-formulas


text:
# simple word embedding
A very simple word embedding layer for LSTM models. For futher information refer to [A Guide to Word Embedding](https://towardsdatascience.com/a-guide-to-word-embeddings-8a23817ab60f) and [Creating Word Embeddings](https://towardsdatascience.com/creating-word-embeddings-coding-the-word2vec-algorithm-in-python-using-deep-learning-b337d0ba17a8).

## How to do it?
Making a Word Embedding is quite straight forward:
1. Gather some text data, prepare them by some preprocessings and define a window parameter (*embedding_dim*)
2. Create the vocabulary
3. Create the windowed contexts
4. Apply *One-Hot encoding*
5. Create, compile and train a model
    - The model consists of 3 layers: Input, Hidden (Dense layer with *window* for the number of units), Output
    - Model output should have *softmax* activation. Also input and output layers should have the same number of shape as the X matrix
6. Get the weights from the model and map them into a dictionary

repository: keivanipchihagh/simple-word-embedding

repo_name: keivanipchihagh/simple-word-embedding


text:
# OpenAppHack

[![Join the chat at https://gitter.im/WiproOpenSourcePractice/openapphack](https://badges.gitter.im/WiproOpenSourcePractice/openapphack.svg)](https://gitter.im/WiproOpenSourcePractice/openapphack?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

Openapphack is an attempt to enable end to end automation of Application Development using opensource tools for provisioning , code authoring and scaffolding.

Openapphack leverages vagrant, ansible and yeoman to do this.

The goal is to get a collection of fully functional , customizable apps working on the [openapphack-vm](https://github.com/WiproOpenSourcePractice/openapphack-vm) from a set of plain `yaml` files.

The broader purpose is to provide a simplified path for full stack developers to quickly get started on opensource technologies and experiment freely.

### Index

- [What is OpenAppHack Project?](https://github.com/WiproOpenSourcePractice/openapphack#what-is-openapphack-project)
- [Openapphack repositories](https://github.com/WiproOpenSourcePractice/openapphack#openapphack-repositories)
- [Contributing to this project](https://github.com/WiproOpenSourcePractice/openapphack#contributing-to-this-project)
- [How do you start your openapphack-project?](https://github.com/WiproOpenSourcePractice/openapphack#how-do-you-start-your-openapphack-project)
  - [How do you customize your openapphack-project?](https://github.com/WiproOpenSourcePractice/openapphack#how-do-you-customize-your-openapphack-project)
  - [How do you test your openapphack-project?](https://github.com/WiproOpenSourcePractice/openapphack#how-do-you-test-your-openapphack-project)
  - [How do you submit your openapphack-project?](https://github.com/WiproOpenSourcePractice/openapphack#how-do-you-submit-your-openapphack-project)

### What is OpenAppHack Project?

An **OpenAppHack Project** is a repository forked from the [openapphack-vm](https://github.com/WiproOpenSourcePractice/openapphack-vm) to your github organization or individual namespace.

You need to make use of the openapphack [ansible](http://www.ansible.com/) roles and openapphack [yeoman](http://yeoman.io/) generators and build an impressive fully functional opensource application.

***

### Openapphack repositories

The others repositories used by the openapphack project are:

[**Openapphack-vm**](https://github.com/WiproOpenSourcePractice/openapphack-vm) : Main repository which participants have to fork and will submit their pull requests.

[**Openapphack-ansible-roles**](https://github.com/WiproOpenSourcePractice/openapphack-ansible-roles) : Repository for ansible roles that can be used by openapphack projects, You can also add your own ansible roles that work on openapphack-vm

[**Openapphack-yeoman-generators**](https://github.com/WiproOpenSourcePractice/openapphack-yeoman-generators) : Repository for the generators. You can also add your own yeoman generators that work on openapphack-vm, [more info](https://github.com/WiproOpenSourcePractice/openapphack-yeoman-generators/wiki/Openapphack-Yeoman-Generators)

***

### Contributing to this project

You can start contributing to this project by starting your own openapphack project as mentioned below.

#### How do you start your openapphack-project?

You begin by forking an [openapphack-vm](https://github.com/WiproOpenSourcePractice/openapphack-vm/) and follow the instructions mentioned [here](https://github.com/WiproOpenSourcePractice/openapphack-vm/blob/master/README.md)

#### How do you customize your openapphack-project?

You are free to tweak the vm configurations as long as the base vagrant box and the openapphack vm folder structure is maintained. Any additional customization must be done only in the `yaml` files.

You are also free to add (**only add**) and include your own yeoman generator and ansible roles as long as they work together on the openapphack-vm.

Please take a look [here](https://github.com/WiproOpenSourcePractice/openapphack-ansible-roles/wiki/Openapphack-Ansible-Roles) , on how to add your own openapphack ansible role

Please take a look [here](https://github.com/WiproOpenSourcePractice/openapphack-yeoman-generators/wiki/Openapphack-Yeoman-Generators) , on how to add your own openapphack yeoman generator

#### How do you test your openapphack-project?

clone your `openapphack-vm` associated with your githubid or org and run vagrant up , vagrant provision.

You should be able to validate and test your vm.

#### How do you submit your openapphack-project? ###

You will have to submit a pull request to [openapphack repository](https://github.com/WiproOpenSourcePractice/openapphack) to do so.

If you are unsure on how to make a pull request. Please refer [github's guide on creating a pull request](https://help.github.com/articles/creating-a-pull-request/)

Do mention your github repository url and details of  any ansible or yeoman generators you have included to get your openapphack project working.

Please join the community @ https://groups.google.com/forum/#!forum/openapphack.

If you have any questions/suggestions please email to [openapphack-queries<EMAIL_ADDRESS>

#### Interested in going the extra mile :

If you want to contribute to the development of openapphack main project please do take a look at the [issues](https://github.com/WiproOpenSourcePractice/openapphack/issues)

You can get details on the branching model that will be followed [here] (http://nvie.com/posts/a-successful-git-branching-model/) ,

## License

This project is licensed under the MIT open source license.

## Credits

Still compiling this.. Lot of Folks to thank, very are standing on the shoulders of a lot of excellant programmers and a lot of opensource projects.

here is a [list]()..


text:
# Change Log
This file contains all the notable changes done to the Ballerina SQL package through the releases.

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

## [Unreleased]

### Changed
- [Improve the Batchupdate query to support string[]](https://github.com/ballerina-platform/ballerina-standard-library/issues/1529)
- [Add support for async operation](https://github.com/ballerina-platform/ballerina-standard-library/issues/120)
- [Add support for queryRow](https://github.com/ballerina-platform/ballerina-standard-library/issues/1604)
- [Add completion type as nil in SQL query return stream type](https://github.com/ballerina-platform/ballerina-standard-library/issues/1654)
- [Implement array types for call procedure](https://github.com/ballerina-platform/ballerina-standard-library/issues/1516)
- [Fix type cast error for query api containing database error](https://github.com/ballerina-platform/ballerina-standard-library/issues/1759)

## [0.6.0-beta.2] - 2021-06-22

### Changed
- [Change default rowType of the query remote method from `nil` to `<>`](https://github.com/ballerina-platform/ballerina-standard-library/issues/1445)

## [0.6.0-beta.1] - 2021-06-02

### Changed
- Add DB connection active status check in native code level
- [Remove sending `lastInsertId` in `ExecutionResult` for remote call function](https://github.com/ballerina-platform/ballerina-standard-library/issues/1409)

### Added
- [Introduced `ArrayValueType` type and `TypedValue` object to configure the types of an SQL array](https://github.com/ballerina-platform/ballerina-standard-library/issues/104)
- Newly introduce TimeWithTimezoneOutParameter and TimestampWithTimezoneOutParameter for using TimeWithTimeZone Type OutParameter

repository: hevayo/module-ballerina-sql

repo_name: hevayo/module-ballerina-sql


text:
# Whatsapp-Spammer
This is a whatsapp spammer made using python
# Installation
```bash
$ pip install selenium
$ pip install pyautogui
```
- Also download ChromeDriver from https://chromedriver.chromium.org/downloads and keep the exe file in the directory containing main.py file

Then run the program using
```bash
$ python3 main.py
```

repository: KKVANONYMOUS/Whatsapp-Spammer

repo_name: KKVANONYMOUS/Whatsapp-Spammer


text:
---
title: Provision and Consume Cloud Resources by Crossplane
---

> ⚠ This section requires your platform builder has already installed the [cloud resources related capabilities](../platform-engineers/cloud-services).

## Provision and consume cloud resource in a single application v1 (one cloud resource)

Check the parameters of cloud resource component:

```shell
$ kubectl vela show alibaba-rds

# Properties
+---------------+------------------------------------------------+--------+----------+--------------------+
|     NAME      |                  DESCRIPTION                   |  TYPE  | REQUIRED |      DEFAULT       |
+---------------+------------------------------------------------+--------+----------+--------------------+
| engine        | RDS engine                                     | string | true     | mysql              |
| engineVersion | The version of RDS engine                      | string | true     |                8.0 |
| instanceClass | The instance class for the RDS                 | string | true     | rds.mysql.c1.large |
| username      | RDS username                                   | string | true     |                    |
| secretName    | Secret name which RDS connection will write to | string | true     |                    |
+---------------+------------------------------------------------+--------+----------+--------------------+
```

Use the service binding trait to bind cloud resources into workload as ENV.

Create an application with a cloud resource provisioning component and a consuming component as below.

```yaml
apiVersion: core.oam.dev/v1beta1
kind: Application
metadata:
  name: webapp
spec:
  components:
    - name: express-server
      type: webservice
      properties:
        image: zzxwill/flask-web-application:v0.3.1-crossplane
        ports: 80
      traits:
        - type: service-binding
          properties:
            envMappings:
              # environments refer to db-conn secret
              DB_PASSWORD:
                secret: db-conn
                key: password                                     # 1) If the env name is different from secret key, secret key has to be set.
              endpoint:
                secret: db-conn                                   # 2) If the env name is the same as the secret key, secret key can be omitted.
              username:
                secret: db-conn

    - name: sample-db
      type: alibaba-rds
      properties:
        name: sample-db
        engine: mysql
        engineVersion: "8.0"
        instanceClass: rds.mysql.c1.large
        username: oamtest
        secretName: db-conn

```

Apply it and verify the application.

```shell
$ kubectl get application
NAME     AGE
webapp   46m

$ kubectl port-forward deployment/express-server 80:80
Forwarding from <IP_ADDRESS>:80 -> 80
Forwarding from [::1]:80 -> 80
Handling connection for 80
Handling connection for 80
```

![](../resources/crossplane-visit-application.jpg)

## Provision and consume cloud resource in a single application v2 (two cloud resources)

Based on the section `Provisioning and consuming cloud resource in a single application v1 (one cloud resource)`,

Update the application to also consume cloud resource OSS.

```yaml
apiVersion: core.oam.dev/v1beta1
kind: Application
metadata:
  name: webapp
spec:
  components:
    - name: express-server
      type: webservice
      properties:
        image: zzxwill/flask-web-application:v0.3.1-crossplane
        ports: 80
      traits:
        - type: service-binding
          properties:
            envMappings:
              # environments refer to db-conn secret
              DB_PASSWORD:
                secret: db-conn
                key: password                                     # 1) If the env name is different from secret key, secret key has to be set.
              endpoint:
                secret: db-conn                                   # 2) If the env name is the same as the secret key, secret key can be omitted.
              username:
                secret: db-conn
              # environments refer to oss-conn secret
              BUCKET_NAME:
                secret: oss-conn
                key: Bucket

    - name: sample-db
      type: alibaba-rds
      properties:
        name: sample-db
        engine: mysql
        engineVersion: "8.0"
        instanceClass: rds.mysql.c1.large
        username: oamtest
        secretName: db-conn

    - name: sample-oss
      type: alibaba-oss
      properties:
        name: velaweb
        secretName: oss-conn
```

Apply it and verify the application.

```shell
$ kubectl port-forward deployment/express-server 80:80
Forwarding from <IP_ADDRESS>:80 -> 80
Forwarding from [::1]:80 -> 80
Handling connection for 80
Handling connection for 80
```

![](../resources/crossplane-visit-application-v2.jpg)

## Provision and consume cloud resource in different applications

In this section, cloud resource will be provisioned in one application and consumed in another application.

### Provision Cloud Resource

Instantiate RDS component with `alibaba-rds` workload type in an [Application](../application) to provide cloud resources.

As we have claimed an RDS instance with ComponentDefinition name `alibaba-rds`.
The component in the application should refer to this type.

```yaml
apiVersion: core.oam.dev/v1beta1
kind: Application
metadata:
  name: baas-rds
spec:
  components:
    - name: sample-db
      type: alibaba-rds
      properties:
        name: sample-db
        engine: mysql
        engineVersion: "8.0"
        instanceClass: rds.mysql.c1.large
        username: oamtest
        secretName: db-conn
```

Apply the application to Kubernetes and a RDS instance will be automatically provisioned (may take some time, ~2 mins).

A secret `db-conn` will also be created in the same namespace as that of the application.

```shell
$ kubectl get application
NAME       AGE
baas-rds   9h

$ kubectl get rdsinstance
NAME           READY   SYNCED   STATE     ENGINE   VERSION   AGE
sample-db-v1   True    True     Running   mysql    8.0       9h

$ kubectl get secret
NAME                                              TYPE                                  DATA   AGE
db-conn                                           connection.crossplane.io/v1alpha1     4      9h

$ ✗ kubectl get secret db-conn -o yaml
apiVersion: v1
data:
  endpoint: xxx==
  password: yyy
  port: MzMwNg==
  username: b2FtdGVzdA==
kind: Secret
```

### Consume the Cloud Resource

In this section, we will show how another component consumes the RDS instance.

> Note: we recommend defining the cloud resource claiming to an independent application if that cloud resource has
> standalone lifecycle.

Now create the Application to consume the data.

```yaml
apiVersion: core.oam.dev/v1beta1
kind: Application
metadata:
  name: webapp
spec:
  components:
    - name: express-server
      type: webconsumer
      properties:
        image: zzxwill/flask-web-application:v0.3.1-crossplane
        ports: 80
        dbSecret: db-conn
```

```shell
$ kubectl get application
NAME       AGE
baas-rds   10h
webapp     14h

$ kubectl get deployment
NAME                READY   UP-TO-DATE   AVAILABLE   AGE
express-server-v1   1/1     1            1           9h

$ kubectl port-forward deployment/express-server 80:80
```

We can see the cloud resource is successfully consumed by the application.

![](../resources/crossplane-visit-application.jpg)


text:
# ChmBatchDecompiler

A simple tool to batch decompile CHM files.

#### Official Site:
<http://www.northbright.com>

#### Dependency

* [WinUtil](https://github.com/northbright/WinUtil):
<https://github.com/northbright/WinUtil>

* ChmBatchDecompiler and WinUtil projects should be in the same folder.

#### Build Env
Visual Studio 2013 for Windows Desktop Express

#### License
MIT License

#### Author
<EMAIL_ADDRESS>

repository: DeionSubav/ChmBatchDecompiler

repo_name: DeionSubav/ChmBatchDecompiler


text:
# Overview

Before we can understand [purescript-purview](https://github.com/paf31/purescript-purview) we need to understand the foundation. That is the [purescript-incremental-functions](https://github.com/paf31/purescript-incremental-functions) package on which purview is based.

## incremental-functions

The core of `incremental-functions` is the typeclass:

```
class Monoid d <= Patch a d | a -> d where
  patch :: a -> d -> a
```

This is kind of like saying we have a "patchable" interface that can be satisfied by any type by implementing the patch function which takes a type `a` and a type `d` (this is a value describing the change to the value of type `a`) and returns another (or the same) value of type `a` and `d` must be a monoid.

This makes more sense if we look at a concrete example.

### [Atomic](https://github.com/paf31/purescript-incremental-functions/blob/master/src/Data/Incremental/Eq.purs#L19)

The simplest "patchable" type is called `Atomic` which just wraps any arbitrary value. The data structure to describe a patch delta for `Atomic` is a `Last` which is a newtype wrapper around `Maybe` with last-wins append (semigroup) implementation.

```
instance patchAtomic :: Patch (Atomic a) (Last a) where
  patch x (Last Nothing) = x
  patch _ (Last (Just y)) = Atomic y
```

so in JavaScript terms this could look like

```
class Atomic {
    constructor(value) {
      this.value = value
    }
    patch(newValue) {
        return newValue == null ? this : new Atomic(delta)
    }
}
```

So in this case the value describing the "change" is a "new" value and we just return the same value unchanged if there is no new value. Otherwise we wrap the new value.

Example:

```
const x = new Atomic(1)
const y = x.patch(2)
const z = y.patch(null)
```

### [IArray](https://github.com/paf31/purescript-incremental-functions/blob/master/src/Data/Incremental/Array.purs)

`IArray` wraps ordinary arrays. The type to describe the "change" is an array of `ArrayChange`s:

```
data ArrayChange a da
  = InsertAt Int a
  | DeleteAt Int
  | ModifyAt Int da
```

and the "patchable" interface:

```
instance patchIArray
    :: Patch a da
    => Patch (IArray a) (Array (ArrayChange a da)) where
  patch (IArray xs) = IArray <<< foldl patchOne xs where
    patchOne xs_ (InsertAt i x)   = fromMaybe xs_ (Array.insertAt i x xs_)
    patchOne xs_ (DeleteAt i)     = fromMaybe xs_ (Array.deleteAt i xs_)
    patchOne xs_ (ModifyAt i da)  = fromMaybe xs_ (Array.modifyAt i (_ `patch` da) xs_)
```

so `patch` takes a list of changes and applies them immutably to create a new IArray with all the changes applied.

### [Jet](https://github.com/paf31/purescript-incremental-functions/blob/096930c94bdaede2a6fb83669065ccf7bc042f7e/src/Data/Incremental.purs#L72)

A Jet is

> a value (`position`) paired with a change (`velocity`).

Jets are the basis for incremental functions like `IArray.map` and purview components.

In the Purescript implementation a `Jet` is a type alias for a record:

```
type Jet a =
  { position :: a
  , velocity :: Change a
  }
```

so it has a `position` of some type `a` and a `velocity` of some type `Change a`.
The `Change` type is used for type level coercion, so when we see a concrete signature like

```
Jet (Atomic Int)
```

is equivalent to

```
{ position :: Atomic Int
, velocity :: Last Int }
```

and

```
Jet (IArray (Atomic Int))
```

this is equivalent to

```
{ position :: IArray Int
, velocity :: Array (ArrayChange Int (Last Int)) }
```

## Incremental Functions

Incremental functions are functions that operate on `Jet`s of "patchable" data structures like `Atomic`, `IArray`, etc.

For example we can map a function over a `Jet (Atomic Int)`.
That means we need to apply a function to the `position`, i.e. the current value and the `velocity` which is the change description (must be a monoid so we have an identity element and we can combine changes).

In the most simple mapping operation we apply a function to a single encapsulated value:

```
class Bla {
  map(f) {
    return new Bla(f(this.value))
  }
}
```

With `Jet`s we have to apply the function to a value and a second value that describes how to change the first.

With the previous JavaScript example code for `Atomic` the change description is a new value or null for no change.

The following example shows how to map over a `Jet Atomic` with our previous example code.
`position` is an `Atomic Int` and `Number | null` is the `velocity`.

```
// map a function over an Atomic <value,change> pair
jetMapAtomic = (f, { position, velocity }) => {
  return {
    position: new Atomic(f(position.value)),
    velocity: velocity != null ? f(velocity) : null
  };
};

jetMapAtomic(count => 'The number is ' + count, {position: new Atomic(1), velocity: null})
// {position: Atomic('The number is 1'), velocity: null}

jetMapAtomic(count => 'The number is ' + count, {position: new Atomic(1), velocity: 7})
// {position: Atomic('The number is 1'), velocity: 'The number is 7'}

```

### Example of mapping over an array and its change description:

```
jetMapArray(n => 'The number is ' + n, {
  position: IArray.of([
    new Atomic(1),
    new Atomic(2)
  ]),
   velocity: [InsertAt(2, new Atomic(3))]
})

// --> {
//     position: IArray([
//         'The number is 1',
//         'The number is 2'
//       ]),
//     velocity: [InsertAt(2, new Atomic('The number is 3'))]
//  })
```

## purview

At the core of purview is a data structure to describe a DOM element and another to describe the changes to a DOM element. Those are the [`View`](<(https://github.com/paf31/purescript-purview/blob/7031081163f0bd6c131099b8bbcfc38af51579d5/src/Purview.purs#L48)>) and [`ViewChanges`](<(https://github.com/paf31/purescript-purview/blob/7031081163f0bd6c131099b8bbcfc38af51579d5/src/Purview.purs#L59)>) types.
Both of those types are newtype wrappers around records:

```
newtype View eff = View
  { element  :: String
  , text     :: Atomic String
  , attrs    :: IMap String (Atomic String)
  , handlers :: IMap String (Atomic (EventListener eff))
  , kids     :: IArray (View eff)
  }

newtype ViewChanges eff = ViewChanges
  { text     :: Last String
  , attrs    :: MapChanges String (Atomic String) (Last String)
  , handlers :: MapChanges String (Atomic (EventListener eff)) (Last (EventListener eff))
  , kids     :: Array (ArrayChange (View eff) (ViewChanges eff))
  }
```

### [Component](https://github.com/paf31/purescript-purview/blob/7031081163f0bd6c131099b8bbcfc38af51579d5/src/Purview.purs#L238)

A purview component is an incremental function, i.e. it operates on `Jet`s.
It takes two parameters: a Jet containing a model (for example an IArray) and a Jet of an Atomic that contains a callback.
The return value is a Jet of `View`s.

> A component takes a changing update function, and a changing `model`
> and returns a changing `View`. The update function receives a `Change` to
> the model and applies it.

```
type Component model eff
   = Jet (Atomic (Change model -> Eff eff Unit))
  -> Jet model
  -> Jet (View eff)
```

### The Loop

The callback function passed to the component receives an appropriate change value to the model and patches the model.
With the new model the component function is called again which produces a `ViewChange` of the view which is then applied to the DOM.

repository: steos/incremental

repo_name: steos/incremental


text:
<img src="https://camo.githubusercontent.com/4f4231b7e0f31e2097e43439ad141c0011aaef58/687474703a2f2f7777772e6170706c69636f6c6f72732e636f6d2f77702d636f6e74656e742f75706c6f6164732f323031392f30312f49636f6e2d312e706e67" alt="alt text" data-canonical-src="http://www.applicolors.com/wp-content/uploads/2019/01/Icon-1.png" width="100">

# MvvmKit
By Kobi Hari (2019)

![GitHub release](https://img.shields.io/github/release-pre/kobi2294/mvvmKit.svg?style=plastic)
![GitHub](https://img.shields.io/github/license/kobi2294/MvvmKit.svg?style=plastic)
![GitHub commit activity](https://img.shields.io/github/commit-activity/m/kobi2294/MvvmKit.svg?style=plastic)
![Nuget](https://img.shields.io/nuget/v/mvvmKit.svg?style=plastic)

## Getting Started
* Install [Visual Studio Extension](https://marketplace.visualstudio.com/items?itemName=kobi2294.MvvmKit) for Templates and Snippets
or
* Add [Nuget Packge](https://www.nuget.org/packages/MvvmKit/):

* The [Documentation](https://github.com/kobi2294/MvvmKit/wiki) is right here, on **Wiki**

## This repository is actually 2 products:
* A general purpose toolkit containing several useful .net packages
* A strongly opinionated MVVM framework that is the sum of my experience develping enterprise WPF Applications

## This framework believes in:
* Unidirectional Binding
* View Model First
* Task based Asynchronous model
* Design time data and "Blendability"
* Region Based Navigation
* "Lazy" loading of hidden view models
* IoC and Dependency Injection

## The framework provides the base classes for your MVVM application, along with several utilities such as:
* Better usage of the IDisposable Pattern
* Complementary classes for TPL
* A set of Delegate classes that rely on Weak References so they allow the target to be garbage collected
* A set of WPF controls that support Unidirectional Data Binding
* And many more extensions and helpers

gha_language: C#


text:
# Changelog

## [0.4.0] - 2021-08-26

This release of Garble adds support for Go 1.17.x while maintaining support for
Go 1.16.x. A few other noteworthy changes are included:

* Support obfuscating literals in more edge cases with `-literals`
* Improve detection of `reflect` usage with standard library APIs
* Names exported for cgo are no longer obfuscated
* Avoid breaking consts using `iota` with `-literals`

Known bugs:

* obfuscating the entire standard library with `GOPRIVATE=*` is not well supported yet

## [0.3.0] - 2021-05-31

This release of Garble fixes a number of bugs and improves existing features,
while maintaining support for Go 1.16.x. Notably:

* Make builds reproducible even when cleaning `GOCACHE`
* Detecting types used with reflection is more reliable
* Cross builds with `GOPRIVATE=*` are now supported
* Support conversion between struct types from different packages
* Improve support for type aliases
* Function names used with `go:linkname` are now obfuscated
* `garble reverse` can now reverse field names and lone filenames

Known bugs:

* obfuscating the entire standard library with `GOPRIVATE=*` is not well supported yet

## [0.2.0] - 2021-04-08

This release of Garble drops support for Go 1.15.x, which is necessary for some
of the enhancements below:

* New: `garble test` allows running Go tests built with obfuscation
* New: `garble reverse` allows de-obfuscating output like stack traces
* Names of functions implemented in assembly are now obfuscated
* `GOPRIVATE=*` now works with packages like `crypto/tls` and `embed`
* `garble build` can now be used with many main packages at once
* `-literals` is more robust and now works on all of `std`

The README is also overhauled to be more helpful to first-time users.

Known bugs:

* obfuscating the entire standard library with `GOPRIVATE=*` is not well supported yet

## [0.1.0] - 2021-03-05

This is the first release of Garble. It supports Go 1.15.x and 1.16.x.

It ships all the major features that have worked for the past year, including:

* Obfuscation of all names, except methods and reflect targets
* Obfuscation of package import paths and position information
* Stripping of build and module information
* Support for Go modules
* Reproducible and cacheable builds
* Stripping of extra information via `-tiny`
* Literal obfuscation via `-literals`

Known bugs:

* obfuscating the standard library with `GOPRIVATE=*` is not well supported yet
* `garble test` is temporarily disabled, as it is currently broken

[0.4.0]: https://github.com/burrowers/garble/releases/tag/v0.4.0
[0.3.0]: https://github.com/burrowers/garble/releases/tag/v0.3.0
[0.2.0]: https://github.com/burrowers/garble/releases/tag/v0.2.0
[0.1.0]: https://github.com/burrowers/garble/releases/tag/v0.1.0

repository: landv/garble

repo_name: landv/garble


text:
# Hub vs Switch vs Router

## Hub

**Hubs are now largely obsolete, having been replaced by network switches except in very old installations or specialized applications.**
Historically, the main reason for purchasing hubs rather than switches was their price. [^2]

- Hub also know as repeaters operate on **physical layer only**.
Can NOT hadnle higher layer like MAC and IP.
- Hub can NOT process data, all it does is transfers data to every port excluding
the port from where data was generated.
- Hub work only in half duplex mode. i.e. a device connected to a hub can either
send or receive data at a given time, but not both.
- Hub only allow one device to send out data at one time,
otherwise data collisions happen, in this case,
it rejects all devices and tell them to send again, usually device use a random timer

## Switch

A network switch (also called switching hub, bridging hub, officially MAC bridge)
is a computer networking device that connects devices together on a computer network,
by using packet switching to receive, process and forward data to the destination device. [^3]

- A switch is more **intelligent** than a repeater hub, which simply retransmits packets out of every port of the hub excepting the port on which the packet was received, unable to distinguish different recipients, and achieving an overall lower network efficiency
- full duplex mode
- Switches may operate at one or more layers of the OSI model, including the data link and network layers. A device that operates simultaneously at more than one of these layers is known as a multilayer switch.

## Router

A router is a networking device that forwards data packets between computer networks. Routers perform the traffic directing functions on the Internet.
A data packet is typically forwarded from one router to another through the networks that constitute the internetwork until it reaches its destination node. [^4]

- Inteligent switch
- Routing table

**Switches create a network. Routers connect networks. A router links computers to the Internet, so users can share the connection. A router acts as a dispatcher, choosing the best path for information to travel so it's received quickly.** [^5]

## TODO

- [x] so where is hub actually in our daily life? Obsoleted.
- [ ] what is the modem we use
- [x] what is the wifi router we have, it is router and has DHCP
- [ ] Switches can avoid loops through the use of **spanning tree protocol**
- [ ] have a table to demonstrate their difference
- [ ] https://en.wikipedia.org/wiki/Network_switch Layer-specific functionality part talks about the difference a lot
- [ ] http://www.webopedia.com/DidYouKnow/Hardware_Software/router_switch_hub.asp this also tells the difference

## References

[^1]: https://s905060.gitbooks.io/site-reliability-engineer-handbook/content/hubs_vs_switches_vs_routers__networking_device_fundamentals.html
[^2]: https://en.wikipedia.org/wiki/Ethernet_hub
[^3]: https://en.wikipedia.org/wiki/Network_switch
<!-- [^2]: http://www.escotal.com/networkdevices.html -->
[^4]: https://en.wikipedia.org/wiki/Router_(computing)
[^5]: https://www.cisco.com/cisco/web/solutions/small_business/resource_center/articles/connect_employees_and_offices/what_is_a_network_switch/index.html


text:
---
layout: default
---

# 1996-08-16 - RE: email bombing

## Header Data

From: rednax<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 2ad00e53221ec38689946d90fad7282fe971b97046c71fdcfd7721a725d860ce

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1996-08-16 16:28:36 UTC

Raw Date: Sat, 17 Aug 1996 00:28:36 +0800

## Raw message

```
{% raw  %}From: rednax<EMAIL_ADDRESS>Date: Sat, 17 Aug 1996 00:28:36 +0800
To<EMAIL_ADDRESS>Subject: RE: email bombing
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

With reference to se7en's incident, is it because of implications like that
that Up Yours doesn't work?

r 3 |) |\| @ ><

"huh??"

----------------
r 3 |) |\| @ ><
----------------
"everyone's expendable, anything too"

{% endraw %}
```

## Thread

+ Return to [August 1996](/archive/1996/08)

+ Return to "[rednax <rednax@asiapac.net>](/authors/rednax_rednax_at_asiapac_net_)"

+ 1996-08-16 (Sat, 17 Aug 1996 00:28:36 +0800) - RE: email bombing - _rednax<EMAIL_ADDRESS>


text:
# jquery-toast
jquery toast plugin

A jQuery plugin to show Andriod like toast notification in web applications.

1.Add jquery.toast.js  file to your project. Also include jQuery file as these is dependency of the plugin.

2.usage

	$.toast("Hello World",{
		timeout: 3000,  // toast duration (default 3000)
        transitionTime: 800,  // speed of show or hide (default 800)
        cls:'mtoast'   // a hook of class for override (default 'mtoast')
	})

3.Dependency - jQuery


text:
# Django Constants

[![](https://img.shields.io/pypi/v/django-constants.svg)](https://pypi.python.org/pypi/django-constants/)
[![](https://img.shields.io/badge/license-MIT-blue.svg)](https://pypi.python.org/pypi/django-constants/)

[![Codecov](https://img.shields.io/codecov/c/github/lukeburden/django-constants.svg)](https://codecov.io/gh/lukeburden/django-constants)
[![CircleCI](https://circleci.com/gh/lukeburden/django-constants.svg?style=svg)](https://circleci.com/gh/lukeburden/django-constants)
![](https://img.shields.io/github/contributors/lukeburden/django-constants.svg)
![](https://img.shields.io/github/issues-pr/lukeburden/django-constants.svg)
![](https://img.shields.io/github/issues-pr-closed/lukeburden/django-constants.svg)

## django-constants

`django-constants` is a utility for Django that makes the definition, use and storage of both integer and string based constants easy and readable. It avoids passing of constants
into template contexts and makes evaluation concise and readable.

It also makes exposure of these constants via forms and DRF serializers simple.

### Definition ###

Constants can be defined with friendly names, backed by either integers or text.

#### Constants ####

```python
from constants.constants import Constant

# states backed by integers
states = Constants(
    Constant(pending=0),
    Constant(active=1),
    Constant(inactive=2)
)

# and another set of constants backed by strings
colours = Constants(
    Constant(red="FF0000"),
    Constant(green="00FF00"),
    Constant(yellow="FFFF80"),
    Constant(white="FFFFFF")
)

```

#### Constant groups ####

At times, it will be necessary to group constants and test membership within that group.
To achieve this, `django-constants` provides a `ConstantGroup` class.

```python
from constants.constants import Constant, ConstantGroup

# states backed by integers
states = Constants(
    Constant(active=0),
    Constant(cancelled_ontime=1),
    Constant(cancelled_late=2),
    ConstantGroup(
        "cancelled",
        ("cancelled_ontime", "cancelled_late")
    )
)

```

#### Within a model ####

While not strictly necessary, it is advisable to effectively namespace your constants
by defining them in the scope of a model definition. This means you have your constants
wherever you have the model class, as well as any model instance.

```python
from django.db import models
from django.utils.translation import ugettext_lazy as _

from constants.constants import Constant, ConstantGroup, Constants
from constants.models.fields import (
    ConstantChoiceCharField,
    ConstantChoiceField
)

class Apple(models.Model):

    purposes = Constants(
        Constant(cooking=0, label=_("Cook me!")),
        Constant(eating=1, label=_("Eat me!")),
        Constant(juicing=2, label=_("Juice me!")),
        Constant(ornamental=3, label=_("Just look how pretty I am!")),
        ConstantGroup(
            "culinary", ("cooking", "eating", "juicing")
        )
    )
    colours = Constants(
        Constant(red="FF0000", label=_("red")),
        Constant(green="00FF00", label=_("green")),
        Constant(yellow="FFFF80", label=_("yellow")),
        Constant(white="FFFFFF", label=_("white")),
    )

    name = models.CharField(max_length=30)
    purpose = ConstantChoiceField(constants=purposes)
    colour = ConstantChoiceCharField(constants=colours, max_length=30)

```

### Use ###

The entire point of this library is to make the use of constants defined in this way
easy and concise.

#### In code ####

```python
apple = Apple.objects.get(name='Granny Smith')
apple.purpose.cooking == True
True
apple.colour.red == True
True
apple.colour.green == True
False

# we don't care about the specific purpose, just whether it is as food
# or not, so use the ConstantGroup!
apple.purpose.culinary == True
True

```

#### In templates ####

```
{% if apple.purpose.eating %}
    You should bite this {{ apple.name }}!
{% endif %}
```

#### With Django's ORM ####

```python
red_apples = Apple.objects.filter(colour=Apple.colours.red)
culinary_apples = Apple.objects.filter(
    purpose__in=Apple.purposes.culinary
)

```

#### With Django Rest Framework ####

Coming soon.

## Contribute

`django-constants` supports a variety of Python and Django versions. It's best if you test each one of these before committing. Our [Circle CI Integration](https://circleci.com will test these when you push but knowing before you commit prevents from having to do a lot of extra commits to get the build to pass.

### Environment Setup

In order to easily test on all these Pythons and run the exact same thing that Travis CI will execute you'll want to setup [pyenv](https://github.com/yyuu/pyenv) and install the Python versions outlined in [tox.ini](tox.ini).

If you are on the Mac, it's recommended you use [brew](http://brew.sh/). After installing `brew` run:

```
$ brew install pyenv pyenv-virtualenv pyenv-virtualenvwrapper
```

Then:

```
pyenv install -s 2.7.14
pyenv install -s 3.4.7
pyenv install -s 3.5.4
pyenv install -s 3.6.3
pyenv virtualenv 2.7.14
pyenv virtualenv 3.4.7
pyenv virtualenv 3.5.4
pyenv virtualenv 3.6.3
pyenv global 2.7.14 3.4.7 3.5.4 3.6.3
pip install detox
```

To run test suite:

Make sure you are NOT inside a `virtualenv` and then:

```
$ detox
```

This will execute the testing matrix in parallel as defined in the `tox.ini`.

repository: sburns/django-constants

repo_name: sburns/django-constants


text:
---
layout: single
title: "Simple Question Answering API using spaCy and nmslib"
category: NLP
abstract: "Simple Example of building question answering API using spaCy and nmslib"

header:
  image: /images/posts/question_answering.jpg
  teaser: /images/posts/question_answering.jpg
---

Question answering is very popular task in NLP. Each routine agent work can be replaced using such system.
So imagine you have a list of frequently asked questions and it's answers. Then you can easily automate the job
of operator using simple NLP pipeline which I will describe here.

## **Problem**:
Given the list of questions and their answers, our goal is to build a ml model which will match questions to
right answers.

## **Solution**:
We can use text similarity. We can calculate embedding of all questions and index them in any database that
supports vector similarity search. One such library which is [nmslib](https://github.com/nmslib/nmslib). It works
really fast and is able to search 10^5 samples per second (see [benchmark](http://ann-benchmarks.com/)).
For calculating text embeddings we can use very popular NLP library [spaCy](https://spacy.io/). So, we will
embed all questions and index them using nmslib. When we get a question, we just calculate it's embedding and
then find closest embedding vector indexed in nmslib. We will assume that the question is very close to one of which
closest embedding was found. If the distance is lower than some threshold, we can return the answer linked to given
question.

## **Example Data**:

|          | question                                               | answer                      |
|----------|--------------------------------------------------------|-----------------------------|
| 0        | Carl and the Passions changed band name to what        | Beach Boys                  |
| 1        | How many rings on the Olympic flag                     | Five                        |
| 2        | What colour is vermilion a shade of                    | Red                         |
| 3        | King Zog ruled which country                           | Albania                     |
| 4        | What colour is Spock's blood                           | Green                       |
| 5        | Where in your body is your patella                     | Knee ( it's the kneecap )   |
| 6        | Where can you find London bridge today                 | USA ( Arizona )             |
| 7        | What spirit is mixed with ginger beer in a Moscow mule | Vodka                       |
| 8        | Who was the first man in space                         | Yuri Gagarin                |
| 9        | What would you do with a Yashmak                       | Wear it - it's an Arab veil |
| 10       | Who betrayed Jesus to the Romans                       | Judas Escariot              |

## **Notebook**:

## Imports

```python
import pandas as pd
import os
import json
import re
import spacy
import nmslib
```

```python
!pip install nmslib
```

```python
!python -m spacy download en
```

```python
!pip install xlrd
```

# Read xslx file sheet

```python
data = pd.read_excel('../data/QA_(0-100).xlsx','Sheet1',  index_col=0, header=None)
```

```python
data = data.iloc[:, 0:2].reset_index(drop=True)
```

```python
data.columns = ['question', 'answer']
```

```python
data.head(2)
```

|          | question                                        | answer     |
|----------|-------------------------------------------------|------------|
| 0        | Carl and the Passions changed band name to what | Beach Boys |
| 1        | How many rings on the Olympic flag              | Five       |

# Create QA model class

```python
class QA(object):
    def __init__(self, data):
        self.nlp = spacy.load('en')
        self.questions = data.question.tolist()
        self.answers = data.answer.tolist()

    def to_vectors(self, texts):
        """Convert texts into their vectors"""
        result = []
        for item in texts:
            result.append(self.nlp(item).vector)

        return result

    def build_nmslib_index(self):
        """build nmslib index with vectors of question texts"""
        self.index = {}
        self.index = nmslib.init(method='hnsw', space='cosinesimil')
        self.index.addDataPointBatch(self.to_vectors(self.questions))
        self.index.createIndex({'post': 2}, print_progress=True)

    def search(self, text, max_distance=0.2):
        """
        K-Nearest-Neighbour search over indexed taxonomy data and distance threshold parameter
        to get most similar one.
        Args:
            text: (str) sample question text
            max_distance: (float) maximum allowed distance for neighbours

        Returns:
            result: (tuple) index and distance for found item

        """
        result = {}
        vector = self.nlp(text).vector

        if vector is not None:
            ids, distances = self.index.knnQuery(vector)

            if ids is not None and distances is not None:
                best_indices_mask = (distances == distances.min()) & (distances < max_distance)
                if best_indices_mask.sum() != 0:
                    result = {'index': ids[best_indices_mask][0], 'distance': distances[best_indices_mask][0]}

        return result

    def query(self, question, max_distance=0.2):
        search_result = self.search(question, max_distance)
        index, distance = search_result.get('index', -1), search_result.get('distance', -1)
        result = "N/A"
        if index != -1:
            result = self.answers[index]

        return result
```

```python
qa = QA(data)
qa.build_nmslib_index()
```

```python
qa.query('Carl and the Passions day changed band name to what', max_distance=0.05)
```
    'Beach Boys'

```python
data.head(2)
```

|   | question                                        | answer     |
|---|-------------------------------------------------|------------|
| 0 | Carl and the Passions changed band name to what | Beach Boys |
| 1 | How many rings on the Olympic flag              | Five       |

```python
preds = data.question.apply(lambda x: qa.query(x))
```

Full source code can be found [here](https://github.com/AnzorGozalishvili/QA_using_spacy_and_nmslib)

gha_language: Ruby


text:
SwiftBiometricLogin
-----------

## iOS Biometric Local Authentication using Swift
Project that allows the easy implementation of the session start with touch ID in iOS.
- Written with Swift
- Customizable

## Installation
Download and implement TouchIDClass in your Project.

## Usage
```swift
class ViewController: UIViewController {

  /// the button to enter via touch id will be hidden by default, until the user has set up an account.

    @IBOutlet weak var touchIDButton: UIButton!
    @IBOutlet weak var LabelTouch: UILabel!

    let biometric = BiometricClass()

    override func viewWillAppear(_ animated: Bool) {

        biometric.activeButtons(touchIDButton, labelTitle: LabelTouch)
    }

    override func viewDidLoad() {
        super.viewDidLoad()

        biometric.imageToFaceID = UIImage(named: "FaceIcon") ?? UIImage.init()
        biometric.imageToTouchID = UIImage(named: "Touch-icon-lg") ?? UIImage.init()
        biometric.configure(touchIDButton, labelTitle: LabelTouch)
        biometric.delegate = self

        // Do any additional setup after loading the view.
    }
}
/// Implement Delegate
extension ViewController : biometricResponse{

    func loginWithBiometric(_ error: String?, user: String, pass: String) {

       // Check if everything was correct, to get the credentials to use
    }
}
```
## Usage without Buttons
```swift
class ViewController: UIViewController {

 	let biometric = BiometricClass()

   override func viewDidLoad() {
        super.viewDidLoad()

        biometric.configure(nil, labelTitle: nil)
        biometric.delegate = self
	// Do any additional setup after loading the view.
    }

    func loginWithTouch(){

	/// Call this method when you want to try to login
	biometric.login(nil)
    }
}
/// Implement Delegate
extension ViewController : biometricResponse{

    func loginWithBiometric(_ error: String?, user: String, pass: String) {

       // Check if everything was correct, to get the credentials to use

    }
}
```
/// This method must be used when the user has successfully logged in. It allows saving or modifying the previously saved user

## Save Credential
```swift

///When your connection is finished, store the user variable and password used by the user momentarily, and save as or modify the existing one as touch ID credential

func successLogin(){

	 biometric.checkBiometricLogin('UserTosave', 'PasstoSave', controller: 	self)	{ [weak self](success) in }
	 // Check if everything was correct, to save or editing credential and continue to next screen
}
```
Customization
-----------

#### Variables:

You can change the text of the alerts in these cases:

| var | value |
| ------ | ------ |
| editCredentialTitleText | "Can you change your credentials of" |
| saveCredentialTitleText | "Next time, would you like log in faster with" |
| messageAlert | "log in fast, easy and secure" |

_**Note:** The variables to edit and save are always completed with the login method to be used.

#### Example:

```
"Can you change your credentials of TouchID" or "Next time, would you like log in faster with FaceID"
```

License
---------
MIT License.

© 2019, Anthony Merida.

Credits
----------

Razeware LLC

Created and maintained by Anthony Merida, © 2019.


text:
# Contributing

1. Before sending pull request run linter, spell checking and tests with `yarn test` or `npm test`
2. If you added new words to .md files, you can get spell check error. Fell free to add new terms to dictionary at `.yaspellerrc` config.

repository: frsv/validate-po

repo_name: frsv/validate-po


text:
Row operations: Create, update and list table rows in HBase
===========================================================

Those operations are handled by the class "PopHbaseTable" which can be retrieved from an instance of "PopHbase" through the "tables" property.

Grab an instance of "PopHbaseRow"
---------------------------------

	$row = $hbase->tables->my_table->my_row;
	assert($row instanceof PopHbaseTableRow);
	assert($hbase->tables->my_table->my_row !== $row);

Retrieve a column value from HBase
----------------------------------

Getting a value from HBase is achieved through the "PopHbaseTableRow->get" method and its magick shortcut. It takes a single argument, the column name, in the form of the column family followed by colons followed by the column name.

	$row = $hbase->tables->my_table->my_row;

	// Using the "get" method
	$row->get('my_column_family:my_column');

	// Using the magick method
	$row->{'my_column_family:my_column'};

Insert and update of a row and a column value
---------------------------------------------

In HBase, inserting and updating operation of rows and column values are the same operation.

	$row = $hbase->tables->my_table->my_new_or_existing_row;
	$row->put('my_column_family:my_column','my_value');

Delete a row from an HBase table
--------------------------------

Row removal is achieved by calling the "PopHbaseRow->delete" method without any argument.

	$row = $hbase->tables->my_table->my_row;
	$row->delete();

gha_language: PHP


text:
### unregister

The `unregister` command will remove shortcuts and file associations for the specified image from the host device.

```
Usage: spoon unregister <image>
```

If the specified image has not been previously registered to the host device using the `spoon register` command, then no action will be taken.

repository: kevholditch/docs

repo_name: kevholditch/docs


text:
# Terms and Conditions

Welcome to Website Name!

These terms and conditions outline the rules and regulations for the use of Company Name's Website, located at Website.com.

By accessing this website we assume you accept these terms and conditions. Do not continue to use Website Name if you do not agree to take all of the terms and conditions stated on this page.dzdszszdzdezdadzad

The following terminology applies to these Terms and Conditions, Privacy Statement and Disclaimer Notice and all Agreements: “Client”, “You” and “Your” refers to you, the person log on this website and compliant to the Company's terms and conditions. “The Company”, “Ourselves”, “We”, “Our” and “Us”, refers to our Company. “Party”, “Parties”, or “Us”, refers to both the Client and ourselves. All terms refer to the offer, acceptance and consideration of payment necessary to undertake the process of our assistance to the Client in the most appropriate manner for the express purpose of meeting the Client's needs in respect of provision of the Company's stated services, in accordance with and subject to, prevailing law of Netherlands. Any use of the above terminology or other words in the singular, plural, capitalization and/or he/she or they, are taken as interchangeable and therefore as referring to same.

## Cookies

We employ the use of cookies. By accessing Webdsite Name, you agreed to use cookies in agreement with the Company Name's Privacy Policy.

Most interactive websites use cookies to let us retrieve the user's details for each visit. Cookies are used by our website to enable the functionality of certain areas to make it easier for people visiting our website. Some of our affiliate/advertising partners may also use cookies.

## License

Unless otherwise stated, Company Name and/or its licensors own the intellectual property rights for all material on Website Name. All intellectual property rights are reserved. You may access this from Website Name for your own personal use subjected to restrictions set in these terms and conditions.

You must not:

- Republish material from Website Name
- Sell, rent or sub-license material from Website Name
- Reproduce, duplicate or copy material from Website Name
- Redistribute content from Website Name

This Agreement shall begin on the date hereof.

Parts of this website offer an opportunity for users to post and exchange opinions and information in certain areas of the website. Company Name does not filter, edit, publish or review Comments prior to their presence on the website. Comments do not reflect the views and opinions of Company Name,its agents and/or affiliates. Comments reflect the views and opinions of the person who post their views and opinions. To the extent permitted by applicable laws, Company Name shall not be liable for the Comments or for any liability, damages or expenses caused and/or suffered as a result of any use of and/or posting of and/or appearance of the Comments on this website.

Company Name reserves the right to monitor all Comments and to remove any Comments which can be considered inappropriate, offensive or causes breach of these Terms and Conditions.

You warrant and represent that:

- You are entitled to post the Comments on our website and have all necessary licenses and consents to do so;
- The Comments do not invade any intellectual property right, including without limitation copyright, patent or trademark of any third party;
- The Comments do not contain any defamatory, libelous, offensive, indecent or otherwise unlawful material which is an invasion of privacy
- The Comments will not be used to solicit or promote business or custom or present commercial activities or unlawful activity.

You hereby grant Company Name a non-exclusive license to use, reproduce, edit and authorize others to use, reproduce and edit any of your Comments in any and all forms, formats or media.

## Hyperlinking to our Content

The following organizations may link to our Website without prior written approval:

- Government agencies;
- Search engines;
- News organizations;
- Online directory distributors may link to our Website in the same manner as they hyperlink to the Websites of other listed businesses; and
- System wide Accredited Businesses except soliciting non-profit organizations, charity shopping malls, and charity fundraising groups which may not hyperlink to our Web site.

These organizations may link to our home page, to publications or to other Website information so long as the link: (a) is not in any way deceptive; (b) does not falsely imply sponsorship, endorsement or approval of the linking party and its products and/or services; and (c) fits within the context of the linking party's site.

We may consider and approve other link requests from the following types of organizations:

- commonly-known consumer and/or business information sources;
- dot.com community sites;
- associations or other groups representing charities;
- online directory distributors;
- internet portals;
- accounting, law and consulting firms; and
- educational institutions and trade associations.

We will approve link requests from these organizations if we decide that: (a) the link would not make us look unfavorably to ourselves or to our accredited businesses; (b) the organization does not have any negative records with us; (c) the benefit to us from the visibility of the hyperlink compensates the absence of Company Name; and (d) the link is in the context of general resource information.

These organizations may link to our home page so long as the link: (a) is not in any way deceptive; (b) does not falsely imply sponsorship, endorsement or approval of the linking party and its products or services; and (c) fits within the context of the linking party's site.

If you are one of the organizations listed in paragraph 2 above and are interested in linking to our website, you must inform us by sending an e-mail to Company Name. Please include your name, your organization name, contact information as well as the URL of your site, a list of any URLs from which you intend to link to our Website, and a list of the URLs on our site to which you would like to link. Wait 2-3 weeks for a response.

Approved organizations may hyperlink to our Website as follows:

- By use of our corporate name; or
- By use of the uniform resource locator being linked to; or
- By use of any other description of our Website being linked to that makes sense within the context and format of content on the linking party's site.

No use of Company Name's logo or other artwork will be allowed for linking absent a trademark license agreement.

## iFrames

Without prior approval and written permission, you may not create frames around our Webpages that alter in any way the visual presentation or appearance of our Website.

## Content Liability

We shall not be hold responsible for any content that appears on your Website. You agree to protect and defend us against all claims that is rising on your Website. No link(s) should appear on any Website that may be interpreted as libelous, obscene or criminal, or which infringes, otherwise violates, or advocates the infringement or other violation of, any third party rights.

## Reservation of Rights

We reserve the right to request that you remove all links or any particular link to our Website. You approve to immediately remove all links to our Website upon request. We also reserve the right to amen these terms and conditions and it's linking policy at any time. By continuously linking to our Website, you agree to be bound to and follow these linking terms and conditions.

## Removal of links from our website

If you find any link on our Website that is offensive for any reason, you are free to contact and inform us any moment. We will consider requests to remove links but we are not obligated to or so or to respond to you directly.

We do not ensure that the information on this website is correct, we do not warrant its completeness or accuracy; nor do we promise to ensure that the website remains available or that the material on the website is kept up to date.

## Disclaimer

To the maximum extent permitted by applicable law, we exclude all representations, warranties and conditions relating to our website and the use of this website. Nothing in this disclaimer will:

- limit or exclude our or your liability for death or personal injury;
- limit or exclude our or your liability for fraud or fraudulent misrepresentation;
- limit any of our or your liabilities in any way that is not permitted under applicable law; or
- exclude any of our or your liabilities that may not be excluded under applicable law.

The limitations and prohibitions of liability set in this Section and elsewhere in this disclaimer: (a) are subject to the preceding paragraph; and (b) govern all liabilities arising under the disclaimer, including liabilities arising in contract, in tort and for breach of statutory duty.

As long as the website and the information and services on the website are provided free of charge, we will not be liable for any loss or damage of any nature.

repository: weareopensource/Node

gha_license_id: NOASSERTION

repo_name: weareopensource/Node