text:
# JupyterLab Top Bar Extensions

[![Extension status](https://img.shields.io/badge/status-ready-success 'ready to be used')](https://jupyterlab-contrib.github.io/)
[![Github Actions Status](https://github.com/jupyterlab-contrib/jupyterlab-topbar/workflows/Build/badge.svg)](https://github.com/jupyterlab-contrib/jupyterlab-topbar/actions/workflows/build.yml)
[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/jupyterlab-contrib/jupyterlab-topbar/main?urlpath=lab)
[![PyPI](https://img.shields.io/pypi/v/jupyterlab-topbar.svg)](https://pypi.org/project/jupyterlab-topbar)

Monorepo to experiment with the top bar space in JupyterLab.

Similar to the [status bar](https://github.com/jupyterlab/jupyterlab/tree/master/packages/statusbar-extension), the top bar can be used to place a few indicators and optimize the overall space.

Inspired by Gnome Shell Top Bar indicators.

![screencast](./doc/screencast.gif)

### Extensions

- [jupyterlab-topbar-text](./packages/topbar-text-extension): add and edit custom text
- [jupyterlab-system-monitor](./packages/system-monitor-extension): show system metrics (memory usage)
- [jupyterlab-logout](./packages/logout-extension): add a "Log Out" button
- [jupyterlab-theme-toggle](./packages/theme-toggler-extension): switch between the Light and Dark themes

## Try it online

Try the extensions in your browser with Binder:

[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/jupyterlab-contrib/jupyterlab-topbar/main?urlpath=lab)

## Installation

### JupyterLab 4.x

Use latest versions of the extensions. **Note** that `jupyterlab-system-monitor`
extension will be distributed along with `jupyter-resource-usage` package for
JupyterLab 4.x

```bash
# topbar text extension
pip install jupyterlab-topbar-text

# logout extension
pip install jupyterlab-logout

# theme toggler extension
pip install jupyterlab-theme-toggler
```

### JupyterLab 3.0

Use pinned versions as the latest version is incompatible with JupyterLab 3.x

```bash
# topbar text extension
pip install jupyterlab-topbar-text==0.6.2

# system monitor extension
pip install jupyterlab-system-monitor==0.8.0

# logout extension
pip install jupyterlab-logout==0.5.0

# theme toggler extension. Install it as labextension
jupyter labextension install jupyterlab-topbar-extension jupyterlab-theme-toggle
```

### JupyterLab 1.x and 2.x

```bash
# container extension
jupyter labextension install jupyterlab-topbar-extension

# system metrics
jupyter labextension install jupyterlab-system-monitor
pip install jupyter-resource-usage

# custom text in the top bar
jupyter labextension install jupyterlab-topbar-text

# add a logout button
jupyter labextension install jupyterlab-logout

# theme toggling extension
jupyter labextension install jupyterlab-theme-toggle
```

All-in-one install:

```bash
jupyter labextension install jupyterlab-topbar-extension \
                             jupyterlab-system-monitor \
                             jupyterlab-topbar-text \
                             jupyterlab-logout \
                             jupyterlab-theme-toggle
```

## Development

Note: You will need NodeJS to build the extension package.

The `jlpm` command is JupyterLab's pinned version of
[yarn](https://yarnpkg.com/) that is installed with JupyterLab. You may use
`yarn` or `npm` in lieu of `jlpm` below.

```bash
# Clone the repo to your local environment
# Change directory into the package that we want to develop
cd packages/<extension_name>
# Install package in development mode
pip install -e .
# Link your development version of the extension with JupyterLab
jupyter labextension develop . --overwrite
# Rebuild extension Typescript source after making changes
jlpm run build
```

You can watch the source directory and run JupyterLab at the same time in different terminals to watch for changes in the extension's source and automatically rebuild the extension.

```bash
# Watch the source directory in one terminal, automatically rebuilding when needed
jlpm run watch
# Run JupyterLab in another terminal
jupyter lab
```

With the watch command running, every saved change will immediately be built locally and available in your running JupyterLab. Refresh JupyterLab to load the change in your browser (you may need to wait several seconds for the extension to be rebuilt).

By default, the `jlpm run build` command generates the source maps for this extension to make it easier to debug using the browser dev tools. To also generate source maps for the JupyterLab core extensions, you can run the following command:

```bash
jupyter lab build --minimize=False
```

### Uninstall

```bash
pip uninstall jupyterlab_topbar_text jupyterlab_logout jupyterlab_theme_toggler
```

repository: jtpio/jupyterlab-topbar

repo_name: jtpio/jupyterlab-topbar


text:
# Flarum BBCode - Advanced Image

Adds an image BBCode to Flarum which allows extra attributes compared to the default image BBCode.

The default image BBCode is `[img]` and so in order to not cause conflicts, this BBCode uses the full word, `[image]`.

The code with all options (although, only the URL is required):

`[image=example.com/image.png width=100 unit=% class=cool alt=This in image title=The title]`

Install using composer:
`composer require zerosonesfun/flarum-bbcode-advanced-image:"*"`

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# Total-Text-Dataset (Official site)
Updated on April 06, 2022 (Detection leaderboard is updated with FCE, ABPNet, PCR, CentripetalText & HierText)

Updated on April 29, 2020 (Detection leaderboard is updated - highlighted E2E methods. Thank you [shine-lcy](https://github.com/shine-lcy).)

Updated on March 19, 2020 (Query on the new groundtruth of test set)

Updated on Sept. 08, 2019 (New [training groundtruth](https://github.com/cs-chan/Total-Text-Dataset/tree/master/Groundtruth/Text) of Total-Text is now available)

Updated on Sept. 07, 2019 (Updated [Guided Annotation toolbox](https://github.com/cs-chan/Total-Text-Dataset/tree/master/Annotation_tools) for scene text image annotation)

Updated on Sept. 07, 2019 (Updated [baseline](https://github.com/cs-chan/Total-Text-Dataset/tree/master/Baseline) as to our IJDAR)

Updated on August 01, 2019 (Extended version with new baseline + annotation tool is accepted at [IJDAR](https://link.springer.com/article/10.1007/s10032-019-00334-z))

Updated on May 30, 2019 (Important announcement on Total-Text vs. ArT dataset)

Updated on April 02, 2019 (Updated table ranking with default vs. our proposed DetEval)

Updated on March 31, 2019 (Faster version DetEval.py, support Python3. Thank you [princewang1994](https://github.com/princewang1994).)

Updated on March 14, 2019 (Updated table ranking with evaluation protocol info.)

Updated on November 26, 2018 (Table ranking is included for reference.)

Updated on August 24, 2018 (Newly added [Guided Annotation toolbox](https://github.com/cs-chan/Total-Text-Dataset/tree/master/Annotation_tools) folder.)

Updated on May 15, 2018 (Added groundtruth in '.txt' format.)

Updated on May 14, 2018 (Added feature - 'Do not care' candidates filtering is now available in the latest python scripts.)

Updated on April 03, 2018 (Added pixel level groundtruth)

Updated on November 04, 2017 (Added text level groundtruth)

Released on October 27, 2017

# News
- We received some questions in regard to the new groundtruth for the test set of Total-Text. Here is an update. We do not           release a new version of the test set groundtruth because

       1) there is no need of standardising the length of the groundtruth vertices for testing purpose, it was proposed to facilitate training only, and
       2) a new version of groundtruth would make the previous benchmarks irrelevant.

Do contact us if you think there is a valid reason to require the new groundtruth for the test set, we shall discuss about it.

- TOTAL-TEXT is a word-level based English curve text dataset. If you are interested in text-line based dataset with both English and Chinese instances, we highly recommend you to refer [SCUT-CTW1500](https://github.com/Yuliang-Liu/Curve-Text-Detector). In addition, a Robust Reading Challenge on Arbitrary-Shaped Text ([RRC-ArT](http://rrc.cvc.uab.es/?ch=14)), which is extended from Total-Text and SCUT-CTW1500, was held at ICDAR2019 to stimulate more innovative ideas on the arbitrary-shaped text reading task. Congratulations to all winners and challengers. The technical report of ArT can be found on at [this https URL](https://arxiv.org/abs/1909.07145).

# Important Announcement
Total-Text and SCUT-CTW1500 are now part of the training set of the largest curved text dataset - [ArT (Arbitrary-Shaped Text dataset)](http://rrc.cvc.uab.es/?ch=14). In order to retain the validity of future benchmarking on Total-Text datasets, the **test-set images** of Total-Text should be removed (with the corresponding ID provided [HERE](https://github.com/cs-chan/Total-Text-Dataset/blob/master/Total_Text_ID_vs_ArT_ID.list)) from the ArT dataset shall one intend to leverage the extra training data from the ArT dataset. We count on the trust of the research community to perform such removal operation to attain the fairness of the benchmarking.

## Table Ranking

- The results from recent papers on Total-Text dataset are listed below where P=Precision, R=Recall & F=F-score.
- If your result is missing or incorrect, please do not hesisate to contact us.
- The baseline scores are based on our proposed [Poly-FRCNN-3] in [this folder](https://github.com/cs-chan/Total-Text-Dataset/tree/master/Baseline).
- *Pascal VOC IoU metric; **Polygon Regression

### Detection Leaderboard

           Method
           Reported
on paper
           DetEval
 (tp=0.4, tr=0.8)
(Default)
           DetEval
(tp=0.6, tr=0.7)
(New Proposal)
           Published at

            P
            R
            F
            P
            R
            F
            P
            R
            F

           Our Baseline [paper]
           78.0
           68.0
           73.0
           -
           -
           -
           78.0
           68.0
           73.0
           IJDAR2020

           CentripetalText [paper]
           90.67
           85.19
           87.85
           -
           -
           -
           -
           -
           -
           NeurIPS2021

           ABPNet [paper]
           90.6
           82.5
           86.3
           -
           -
           -
           -
           -
           -
           ICCV2021

           CRAFTS [paper]
           89.5
           85.4
           87.4
           -
           -
           -
           -
           -
           -
           ECCV2020

           FCE [paper]
           89.3
           82.5
           85.8
           -
           -
           -
           -
           -
           -
           CVPR2021

           #ASTS_Weakly-ResNet101 (E2E) [paper]
           -
           -
           87.3
           -
           -
           -
           -
           -
           -
           TIP2020

           TextFuseNet [paper]
           89.0
           85.3
           87.1
           -
           -
           -
           -
           -
           -
           IJCAI2020

           #Boundary (E2E) [paper]
           88.9
           85.0
           87.0
           -
           -
           -
           -
           -
           -
           AAAI2020

           PCR [paper]
           88.5
           82.0
           85.2
           -
           -
           -
           -
           -
           -
           CVPR2021

           PolyPRNet [paper]
           88.1
           85.3
           86.7
           -
           -
           -
           -
           -
           -
           ACCV2020

           #Qin et al. (E2E) [paper]
           87.8
           85.0
           86.4
           -
           -
           -
           -
           -
           -
           ICCV2019

           100%Poly [paper]
           88.2
           83.3
           85.6
           -
           -
           -
           -
           -
           -
           arXiv:2012

           ContourNet [paper]
           86.9
           83.9
           85.4
           -
           -
           -
           -
           -
           -
           CVPR2020

           #Text Perceptron (E2E) [paper]
           88.8
           81.8
           85.2
           -
           -
           -
           -
           -
           -
           AAAI2020

           PAN-640 [paper]
           89.3
           81.0
           85.0
           -
           -
           -
           -
           -
           -
           ICCV2019

           DB-ResNet50 (800) [paper]
           87.1
           82.5
           84.7
           -
           -
           -
           -
           -
           -
           AAAI2020

           TextCohesion [paper]
           88.1
           81.4
           84.6
           -
           -
           -
           -
           -
           -
           arXiv:1904

           Feng et al. <a href="http://<IP_ADDRESS>/bitstream/173211/41453/1/发表版.pdf">[paper]
           87.3
           81.1
           84.1
           -
           -
           -
           -
           -
           -
           IJCV2020

           HierText [paper]
           85.49
           90.53
           87.94
           -
           -
           -
           -
           -
           -
           CVPR2022

           ReLaText [paper]
           84.8
           83.1
           84.0
           -
           -
           -
           -
           -
           -
           arXiv:2003

           CRAFT [paper]
           87.6
           79.9
           83.6
           -
           -
           -
           -
           -
           -
           CVPR2019

           LOMO MS [paper]
           87.6
           79.3
           83.3
           -
           -
           -
           -
           -
           -
           CVPR2019

           SPCNet [paper]
           83.0
           82.8
           82.9
           -
           -
           -
           -
           -
           -
           AAAI2019

           #ABCNet (E2E) [paper]
           85.4
           80.1
           82.7
           -
           -
           -
           -
           -
           -
           CVPR2020

           ICG [paper]
           82.1
           80.9
           81.5
           -
           -
           -
           -
           -
           -
           PR2019

           FTSN [paper]
           *84.7
           *78.0
           *81.3
           -
           -
           -
           -
           -
           -
           ICPR2018

           PSENet-1s [paper]
           84.02
           77.96
           80.87
           -
           -
           -
           -
           -
           -
           CVPR2019

            1TextField [paper]
           81.2
           79.9
           80.6
           76.1
           75.1
           75.6
           83.0
           82.0
           82.5
           TIP2019

           #TextDragon (E2E) [paper]
           85.6
           75.7
           80.3
           -
           -
           -
           -
           -
           -
           ICCV2019

           CSE [paper]
           81.4
(**80.9)
           79.7
(**80.3)
           80.2
(**80.6)
           -
           -
           -
           -
           -
           -
           CVPR2019

           MSR [paper]
           85.2
           73.0
           78.6
           82.7
           68.3
           74.9
           81.4
           72.5
           76.7
           arXiv:1901

           ATTR [paper]
           80.9
           76.2
           78.5
           -
           -
           -
           -
           -
           -
           CVPR2019

           TextSnake [paper]
           82.7
           74.5
           78.4
           -
           -
           -
           -
           -
           -
           ECCV2018

           1CTD [paper]
           74.0
           71.0
           73.0
           60.7
           58.8
           59.8
           76.5
           73.8
           75.2
           PR2019

           #TextNet (E2E) [paper]
           68.2
           59.5
           63.5
           -
           -
           -
           -
           -
           -
           ACCV2018

           #,2Mask TextSpotter (E2E) [paper]
           69.0
           55.0
           61.3
           68.9
           62.5
           65.5
           82.5
           75.2
           78.6
           ECCV2018

           CENet [paper]
           59.9
           54.4
           57.0
           -
           -
           -
           -
           -
           -
           ACCV2018

           #Textboxes (E2E) [paper]
           62.1
           45.5
           52.5
           -
           -
           -
           -
           -
           -
           AAAI2017

           EAST [paper]
           50.0
           36.2
           42.0
           -
           -
           -
           -
           -
           -
           CVPR2017

           SegLink [paper]
           30.3
           23.8
           26.7
           -
           -
           -
           -
           -
           -
           CVPR2017

Note:

# Framework that does end-to-end training (i.e. detection + recognition).

1For the results of TextField and CTD, the improved versions of their original paper were used, and this explains why the performance is better.

2For Mask-TextSpotter, the relatively poor performance reported in their paper was due to a bug in the input reading module (which was fixed recently). The authors were informed about this issue.

### End-to-end Recognition Leaderboard
 (None refers to recognition without any lexicon; Full lexicon contains all words in test set.)

            Method
            Backbone
            None (%)
            Full (%)
            FPS
            Published at

              CRAFTS [paper]
              ResNet50-FPN
              78.7
              -
              -
              ECCV2020

              MANGO [paper]
              ResNet50-FPN
              72.9
              83.6
              4.3
              AAAI2021

              Text Perceptron [paper]
              ResNet50-FPN
              69.7
              78.3
              -
              AAAI2020

              ABCNet-MS [paper]
              ResNet50-FPN
              69.5
              78.4
              6.9
              CVPR2020

              CharNet H-88 MS [paper]
              ResNet50-Hourglass57
              69.2
              -
              1.2
              ICCV2019

              Qin et al. [paper]
              ResNet50-MSF
              67.8
              -
              -
              ICCV2019

              ASTS_Weakly [paper]
              ResNet101-FPN
              65.3
              84.2
              2.5
              TIP2020

              Boundary [paper]
              ResNet50-FPN
              65.0
              76.1
              -
              AAAI2020

              ABCNet [paper]
              ResNet50-FPN
              64.2
              75.7
              17.9
              CVPR2020

              CAPNet [paper]
              ResNet50-FPN
              62.7
              -
              -
              ICASSP2020

              Feng et al. <a href="http://<IP_ADDRESS>/bitstream/173211/41453/1/发表版.pdf">[paper]
              VGG
              55.8
              79.2
              -
              IJCV2020

              TextNet [paper]
              ResNet50-SAM
              54.0
              -
              2.7
              ACCV2018

              Mask TextSpotter [paper]
              ResNet50-FPN
              52.9
              71.8
              4.8
              ECCV2018

              TextDragon [paper]
              VGG16
              48.8
              74.8
              -
              ICCV2019

              Textboxes [paper]
              ResNet50-FPN
              36.3
              48.9
              1.4
              AAAI2017

## Description

In order to facilitate a new text detection research, we introduce Total-Text dataset [(IJDAR)](http://cs-chan.com/doc/IJDAR2019.pdf)[(ICDAR-17 paper)](https://arxiv.org/abs/1710.10400) [(presentation slides)](http://cs-chan.com/doc/TT_Slide.pdf), which is more comprehensive than the existing text datasets. The Total-Text consists of 1555 images with more than 3 different text orientations: Horizontal, Multi-Oriented, and Curved, one of a kind.

## Citation
If you find this dataset useful for your research, please cite
```bibtex
@article{CK2019,
  author    = {Chee Kheng Ch’ng and
               Chee Seng Chan and
               Chenglin Liu},
  title     = {Total-Text: Towards Orientation Robustness in Scene Text Detection},
  journal   = {International Journal on Document Analysis and Recognition (IJDAR)},
  volume    = {23},
  pages     = {31-52},
  year      = {2020},
  doi       = {10.1007/s10032-019-00334-z},
}
```

## Feedback
Suggestions and opinions of this dataset (both positive and negative) are greatly welcome. Please contact the authors by sending email to
`chngcheekheng at gmail.com` or `cs.chan at um.edu.my`.

## License and Copyright
The project is open source under BSD-3 license (see the ``` LICENSE ``` file).

For commercial purpose usage, please contact Dr. Chee Seng Chan at `cs.chan at um.edu.my`

©2017-2022 Center of Image and Signal Processing, Faculty of Computer Science and Information Technology, Universiti Malaya.

repository: cs-chan/Total-Text-Dataset

gha_language: Python

repo_name: cs-chan/Total-Text-Dataset


text:
![Keycloak plus Clojure](../keycloak-plus-clojure.png)

- [Introduction](#introduction)
  - [Specifics of the choosen Clojure server and ClojureScript client libs](https://github.com/jgrodziski/keycloak-clojure#specifics-of-the-choosen-clojure-server-and-clojurescript-client-libs)
  - [Principles of User Authentication](https://github.com/jgrodziski/keycloak-clojure#principles-of-user-authentication)
- [Principles of User Authentication - Keycloak Core Concepts](https://github.com/jgrodziski/keycloak-clojure#principles-of-user-authentication---keycloak-core-concepts)
- [Installing and Configuring Keycloak](https://github.com/jgrodziski/keycloak-clojure#installing-and-configuring-keycloak)
- [Web Frontend SPA authentication](https://github.com/jgrodziski/keycloak-clojure#web-frontend-spa-authentication)
  - [Lib Installation](https://github.com/jgrodziski/keycloak-clojure#lib-installation)
  - [Initial Authentication Steps](https://github.com/jgrodziski/keycloak-clojure#initial-authentication-steps)
  - [Token Storage](https://github.com/jgrodziski/keycloak-clojure#token-storage)
  - [Token refreshing](https://github.com/jgrodziski/keycloak-clojure#token-refreshing)
- [API Server Authentication](https://github.com/jgrodziski/keycloak-clojure#api-server-authentication)

# Introduction

This repo was first an explanation of integrating Keycloak with Clojure, now I transform it to offer a library to wrap the Keycloak Java Adapter and provide some utilities facilitating the integration. The initial explanation is now in the README of the `sample` directory.

**This article explains the integration of [Keycloak](http://www.keycloak.org), an Identity and Access Management Server in a [Clojure](https://www.clojure.org) ecosystem.**

 The typical application architecture is now a web and mobile frontend talking to a server API (in a REST or GraphQL manner). By the way, Keycloak entered the [Thoughtworks TechRadar in november 2017](https://www.thoughtworks.com/radar/platforms/keycloak) in the Trial category.

## Specifics of the choosen Clojure server and ClojureScript client libs

The main libraries used in the sample app are [Reagent](http://reagent-project.github.io/)/[Re-Frame](https://github.com/Day8/re-frame), React native and [Yada](https://github.com/juxt/yada) for the API backend.
I'll try to clearly separate the inner details of making Keycloak work and those of the surrounding libraries. You should easily adapt the environment as I'll try to explain the reason behind every mechanisms.

The impacting server libs are:
- [Yada](https://github.com/juxt/yada)
- [Mount](https://github.com/tolitius/mount)

The impacting client libs are:
- [re-frame](https://github.com/Day8/re-frame)
- [Mount](https://github.com/tolitius/mount) on the client side

# Principles of User Authentication - Keycloak Core Concepts

*Realm* is the core concept in Keycloak. A *realm* secures and manages security metadata for a set of users, applications and registered oauth clients.

A *client* is a service that is secured by a *realm*. Once your *realm* is created, you can create a *client* i.e. a runtime component talking to keycloak: web frontend code in a browser, mobile frontend code in a React Native app, API server, etc. You will often use Client for every Application secured by Keycloak. When a user browses an application's web site, the application can redirect the user agent to the Keycloak Server and request a login. Once a user is logged in, they can visit any other client (application) managed by the realm and not have to re-enter credentials. This also hold true for logging out. *Roles* can also be defined at the *client* level and assigned to specific users. Depending on the *client* type, you may also be able to view and manage *user* *sessions* from the administration console.

*Adapters* are keycloak librairies in different technologies used for *client* to communicate with the keycloak servers. Luckily thanks to Clojure and Clojurescript running on hosted platform, respectively the JVM and the JS engine, we can use the [Keycloak Java Adapter](http://www.keycloak.org/docs/3.2/securing_apps/topics/oidc/java/java-adapters.html) and the [Keycloak Jsvascript Adapter](http://www.keycloak.org/docs/3.2/securing_apps/topics/oidc/javascript-adapter.html).

[OpenId Connect terminology](http://openid.net/specs/openid-connect-core-1_0.html#Terminology) is implemented by keycloak.

# Installing and Configuring Keycloak
You can use the [JBoss Keycloak docker image](https://hub.docker.com/r/jboss/keycloak/) `docker pull  jboss/keycloak-postgres:3.3.0.Final`
You'll need an SQL database for the storage, here I choose postgresql. There is a lot of documentation out there to configure Keycloak and postgresql, just google it. I put them behind a dockerized nginx proxy that manages quite easily the certificates renewing and proxying of docker container.
I use [nginx proxy](https://github.com/jwilder/nginx-proxy) with the [Letsencrypt nginx proxy companion](https://github.com/JrCs/docker-letsencrypt-nginx-proxy-companion) for the SSL support (SSL access is for me quite mandatory for keycloak...). It's quite easy to setup (just add some env variables to the docker container and that's it) and it works very well.

Now connect to your keycloak administration console and create:
- [a realm](http://www.keycloak.org/docs/latest/getting_started/index.html#_create-realm)
- [in that realm, a client](http://www.keycloak.org/docs/latest/getting_started/index.html#creating-and-registering-the-client)
- in that realm, [a test user](http://www.keycloak.org/docs/latest/getting_started/index.html#_create-new-user)

The client screen has an "installation" tab that allows to grab the credentials secret for this client that will be part of the needed configuration.

# Web Frontend SPA authentication

## Lib installation
The keycloak javascript Adapter library is vanilla JS and does not implement the Google Closure contract, so the integration in the Leiningen cljsbuild should be in the form of a [foreign lib ](https://clojurescript.org/reference/packaging-foreign-deps) in your `project.clj`.

```clojure
  :cljsbuild
  {:builds
   [{:id           "dev"
     :source-paths ["src/cljs"]
     :figwheel     {:on-jsload "myapp.core/mount-root"}
     :compiler     {:main                 myapp.core
                    :output-to            "resources/public/js/compiled/app.js"
                    :output-dir           "resources/public/js/compiled/out"
                    :asset-path           "js/compiled/out"
                    :source-map-timestamp true
                    :preloads             [devtools.preload
                                           day8.re-frame.trace.preload
                                           re-frisk.preload]
                    :closure-defines      {"re_frame.trace.trace_enabled_QMARK_" true}
                    :external-config      {:devtools/config {:features-to-install :all}}
                    :externs ["lib/keycloak/keycloak-externs.js"]
                    :foreign-libs [{:file "lib/keycloak/keycloak.js"
                                    :provides ["keycloak"]}]
                    }}
```

# Mobile frontend authentication
TODO

# API server authentication

Copyright (c) 2017 [Jeremie Grodziski](https://www.grodziski.com) - MIT License

repository: Dorgky/keycloak-clojure

repo_name: Dorgky/keycloak-clojure


text:
# Wecho
Wecho is a small module to simplify usage of sounds on the web with [several sounds](https://gmrchk.github.io/wecho/) provided within the Wecho ([Contributions](#contributions)).

## Installation
```shell
npm install wecho
```
and
```javascript
import Wecho from 'wecho';
```

or include the file from the dist folder

```html
<script src="./dist/wecho.js"></script>
```

## Usage

```javascript
// define options (inlcluded options are default values, so options argument can be omitted)
let options = {
    volume: .5, // can be set for each sound separately
    finishPlaying: false,   // defines whether the sound should restart playing in case it's still being played
    customSounds: {},   // add your own sounds (property is the name of sound and value is the URL)
};

// create instance of Wecho
const wecho = new Wecho(options);

// load desired sounds
wecho.load(['tick', 'boop']);   // empty arguments loads all the sounds

// and play when needed (on click of any button in this example)
document.querySelectorAll('button').forEach(function(element) {
    element.addEventListener('click', function(event) {
        wecho.play('tick');
    });
});
```

## Methods

### add
Adds a sound to the predefined list from which the sounds can be loaded.
```javascript
wecho.add(nameOfSound, URLofSound);
```

### load
Loads sounds with URL from predefined list.
```javascript
wecho.load(['tick', 'boop']);
```

### setVolume
Sets volume for one or all sounds.
```javascript
wecho.setVolume(volume, nameOfSound); // volume accepts 0-1, name of sound is optional
```

### play
Plays sound. Note that sound must be loaded first.
```javascript
wecho.play(soundName);
```

## Contributions
Any suggestions or contributions are welcome.
If you'd like to expand the list of available sounds with your own, create a pull request or open an issue with your files included.

repository: alirealasad/wecho

repo_name: alirealasad/wecho


text:
[Chapter 2 Branch](https://github.com/tme321/ng-DevelopingADataTable/tree/31f8adf235326eea0ef3232b9d3f2baa757e6111)

[Previous: Chapter 1. Initial Datatable Design](/chapters/1._Initial_Datatable_Design.md)

[Next: Chapter 3. Early Performance Considerations](/chapters/3._Early_Performance_Considerations.md)

# Chapter 2
## Testing the Datatable

Before further development I will add some tests.  There isn't much functionality to test yet but by adding tests as I add functionality it will make it less daunting later to have a large and completey untested component.  Also, the tests will ensure that functionality does not accidently drift as development continues.

The tests will mostly be very simplistic; just determining that the table initializes in the correct state and that the `getData` member correctly resolves various cases of `path` and `row` values.

For now the main test is the final one, `'should render the table correctly'`, which sets the `data` and `columns` `Input`s to testing values then verifies that the table rendered with the correct elements and the correct values were put into the elements.

Some of these tests are probably superfluous and I may end up removing them.  But for now I will leave them in as they give a starting point for testing future development and can be easily removed if I determine they are not needed.

[Chapter 2 Branch](https://github.com/tme321/ng-DevelopingADataTable/tree/31f8adf235326eea0ef3232b9d3f2baa757e6111)

[Previous: Chapter 1. Initial Datatable Design](/chapters/1._Initial_Datatable_Design.md)

[Next: Chapter 3. Early Performance Considerations](/chapters/3._Early_Performance_Considerations.md)

gha_language: TypeScript

gha_license_id: MIT


text:
---
layout: post
title: First week at Metis  - Project Benson
---

![Image test](https://raw.githubusercontent.com/dvu4/dvu4.github.io/master/images/mta_nyc.png)

Challenge
-----------

>An email from a potential client:

>*Vinny & Julia -
>It was great to meet with you and chat at the event where we recently met and had a nice chat. We’d love to take some next steps to see if working together is something that would make sense for both parties.
>As we mentioned, we are interested in harnessing the power of data and analytics to optimize the effectiveness of our street team work, which is a significant portion of our fundraising efforts.
>WomenTechWomenYes (WTWY) has an annual gala at the beginning of the summer each year. As we are new and inclusive organization, we try to do double duty with the gala both to fill our event space with individuals passionate about increasing the participation of women in technology, and to concurrently build awareness and reach.
>To this end we place street teams at entrances to subway stations. The street teams collect email addresses and those who sign up are sent free tickets to our gala.
>Where we’d like to solicit your engagement is to use MTA subway data, which as I’m sure you know is available freely from the city, to help us optimize the placement of our street teams, such that we can gather the most signatures, ideally from those who will attend the gala and contribute to our cause.
>The ball is in your court now—do you think this is something that would be feasible for your group? From there we can explore what kind of an engagement would make sense for all of us.
>Best,
>Karrine and Dahlia
>WTWY International*

Approach
-----------
The motivation for this project is help the WTWY figure out the best place and time for them to deploy their street teams, so they can invite more people to the gala. In order to give them a good recommendation, we utilized historical [MTA turnstile data](http://web.mta.info/developers/download.html) and census data [ACS](https://www.census.gov/programs-surveys/acs) to gain the insight of communting pattern in NYC.

Our potential target are female commuters and women working in tech. So, we combined traffic flow from 	MTA data and demographic information to give our client the best location. Because a lot tourists visit NYC and WTWY employees do not work at weekend, Saturday and Sunday are excluded from our recommendation to avoid the potential outliers in riderships data.

Data Analysis
-----------
By exploring the data and analyzing the daily commuter traffic and hour of day traffic, we noticed there is inconsistency in data recorded by hour due to the glitch in the turnstile. Therefore we remove dataset containing negative ridership or ridership greater than 80000 per day.

![daily_traffic](https://raw.githubusercontent.com/dvu4/dvu4.github.io/master/images/daily_traffic.png)

The top five MTA stations we recommend are:

- FULTON ST
- 23 ST
- 86 ST
- 59 ST COLUMBUS
- 14 ST-UNION SQ

![yearly_traffic](https://raw.githubusercontent.com/dvu4/dvu4.github.io/master/images/yearly_traffic.png)

![map_mta](https://raw.githubusercontent.com/dvu4/dvu4.github.io/master/images/mta_map.tif)

Conclusion
-----------
- The stations with the highest traffic have transfers to different lines such as the 23rd Street have connection to different MTA lines and also to buses, which guarantee a high traffic to capture emails

- The morning period (8am -12pm) is the best time to capture emails, followed by the 12-8pm period

- The expansion of data to cover multiple years could help to improve analysis to reduce the effect of outliers and special events

- Expanding street teams outside subway stations can improve target accuracy because not everybody commute to work using the train, adding street teams outside train stations in trendy neighborhoods could increase reach

You can find the project on [Github](https://github.com/dvu4/metis_submission/blob/master/projects/project1/project1.ipynb)


text:
---
layout: default
---

# 1993-11-23 - G.Barnes -- Stellar Hypocrite

## Header Data

From: "L. Detweiler"<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 5ec093197b086239ba16145f52cd1465e74b6ac8e92a534d6a76c929d5defa59

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1993-11-23 07:23:50 UTC

Raw Date: Mon, 22 Nov 93 23:23:50 PST

## Raw message

```
{% raw  %}From: "L. Detweiler"<EMAIL_ADDRESS>Date: Mon, 22 Nov 93 23:23:50 PST
To<EMAIL_ADDRESS>Subject: G.Barnes -- Stellar Hypocrite
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

A friend has just emailed me a copy of Mr. Barnes' outrageous invasions
into my privacy from last week, which just saw for the first time, and
now condemn as a grotesque fishing expedition among my personal
associates with enough influence to censor me. I didn't take his
earlier threats about `going to your personal associates' seriously --
I had no idea anyone could be so perverted. Mr. Barnes, your slimy
tactics are absolutely obscene, and I further doubt that you are acting
alone.

The sheer onslaught of unremitting evil I have been subject to in the
past few weeks make my RISKS articles look like feeble whimperings. The
problem is not that these recent freakshows are little anomalies in the
Cypherpunk `movement'. We are seeing for the first time the true,
unconcealed, rotten core of it. The hideous monster that has until now
hidden in blackness is rearing and screeching at the top of its lungs
upon being discovered. Pseudospoofing, criminal machinations of
identity, lying through the media, and subversion of the Internet and
Cyberspace have been the #1 goals of the Cypherpunks from the
beginning, and their heinous, vicious atrocities have already
irreparably damaged and poisoned very many quarters of the Internet.
The Aliens have Landed.

{% endraw %}
```

## Thread

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

+ Return to "["L. Detweiler" <ld231782@longs.lance.colostate.edu>](/authors/l_detweiler_ld231782_at_longs_lance_colostate_edu_)"

+ 1993-11-23 (Mon, 22 Nov 93 23:23:50 PST) - G.Barnes -- Stellar Hypocrite - _"L. Detweiler"<EMAIL_ADDRESS>


text:
Thank you for your contribution to the LeetCode-31-day-May-2020-Challenge repo. Please raise a different PR for each Coding Problem.
Before submitting this PR, please make sure:

- [ ] Your code passes all test cases as per LeetCode
- [ ] You have analysed the Time and Space complexity

Select the appropriate reason for your PR:

- [ ] Propose a solution in Python with better time/space complexity
- [ ] Propose an alternative solution in Python
- [ ] Propose a solution in any language other than Python
- [ ] Propose an edit/review for a current solution

Any addtional comments/information:


text:
# Metadata generation for ECR repositories
The files in this directory are used to generate text that is manually copied into our
[ECR CDK stack file](resources/cdk/ecr_repositories/ecr_repositories-stack.ts) which is
used as the source config file for our ECR repositories.

This is not example code and is used internally by the AWS team responsible for maintaining
this repository.

repository: awsdocs/aws-doc-sdk-examples

branch_name: refs/heads/main

gha_language: Java

repo_name: awsdocs/aws-doc-sdk-examples


text:
# Fancybox 🔗
A minimal no-nonsense flarum extension which enables all images to be presented in Fancybox by adding a data-fancybox attribute to all img tags (except Emoji)

## Install
`composer require phenomlab/fancybox`

## Update
`composer update phenomlab/fancybox`

## Remove
`composer remove phenomlab/fancybox`

repository: tolgaaaltas/fancybox

repo_name: tolgaaaltas/fancybox


text:
# Northwoods Router

[![Build Status](https://travis-ci.com/northwoods/router.svg?branch=master)](https://travis-ci.com/northwoods/router)
[![Code Quality](https://scrutinizer-ci.com/g/northwoods/router/badges/quality-score.png?b=master)](https://scrutinizer-ci.com/g/northwoods/router/?branch=master)
[![Code Coverage](https://scrutinizer-ci.com/g/northwoods/router/badges/coverage.png?b=master)](https://scrutinizer-ci.com/g/northwoods/router/?branch=master)
[![Latest Stable Version](http://img.shields.io/packagist/v/northwoods/router.svg?style=flat)](https://packagist.org/packages/northwoods/router)
[![Total Downloads](https://img.shields.io/packagist/dt/northwoods/router.svg?style=flat)](https://packagist.org/packages/northwoods/router)
[![License](https://img.shields.io/packagist/l/northwoods/router.svg?style=flat)](https://packagist.org/packages/northwoods/router)

A [FastRoute][fastroute] based router designed to be used with [PSR-15 middleware][psr15].

[fastroute]: https://github.com/nikic/FastRoute
[psr15]: https://www.php-fig.org/psr/psr-15/

## Installation

The best way to install and use this package is with [composer](http://getcomposer.org/):

```shell
composer require northwoods/router
```

## Usage

The router implements `MiddlewareInterface` and can be used with any middleware
dispatcher, such as [Broker][broker].

```php
use Northwoods\Router\Router;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;

$router = new Router();
$router->get('user.list', '/users', $userList);
$router->get('user.detail', '/users/{id:\d+}', $userDetail);
$router->post('user.create', '/users', $userCreate);

assert($router instanceof Psr\Http\Server\MiddlewareInterface);
```

This is the preferred usage of the router, as it ensures that the request is
properly set up for the route handler. Generally the router should be the last
middleware in the stack.

If you prefer to use the router without middleware, the router also implements
`RequestHandlerInterface` and can be used directly:

```php
/** @var ServerRequestInterface */
$request = /* create server request */;

/** @var ResponseInterface */
$response = $router->handle($request);
```

[broker]: https://github.com/northwoods/broker

### Route Handlers

All route handlers MUST implement the `RequestHandlerInterface` interface:

```php
namespace Acme;

use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\RequestHandlerInterface;

class UserListHandler implements RequestHandlerInterface
{
    public function handle(ServerRequestInterface $request): ResponseInterface
    {
        /** @var array */
        $users = /* load from database, etc */;

        return new Response(200, ['content-type' => 'application-json'], json_encode($users));
    }
}
```

If it is preferable to lazy load handlers, the [lazy-middleware][lazy-middleware]
package can be used:

```php
use Northwoods\Middleware\LazyHandlerFactory;

/** @var LazyHandlerFactory */
$lazyHandler = /* create the factory */;

$router->post('user.create', '/users', $lazyHandler->defer(CreateUserHandler::class));
```

[lazy-middleware]: https://github.com/northwoods/lazy-middleware

### Reverse Routing

Reverse routing enables generating URIs from routes:

```php
$uri = $router->uri('user.detail', ['id' => 100]);

assert($uri === '/users/100');
```

## API

### Router::add($name, $route);

Add a fully constructed route.

### Router::get($name, $pattern, $handler)

Add a route that works for HTTP GET requests.

### Router::post($name, $pattern, $handler)

Add a route that works for HTTP POST requests.

### Router::put($name, $pattern, $handler)

Add a route that works for HTTP PUT requests.

### Router::patch($name, $pattern, $handler)

Add a route that works for HTTP PATCH requests.

### Router::delete($name, $pattern, $handler)

Add a route that works for HTTP DELETE requests.

### Router::head($name, $pattern, $handler)

Add a route that works for HTTP HEAD requests.

### Router::options($name, $pattern, $handler)

Add a route that works for HTTP OPTIONS requests.

### Router::process($request, $handler)

Dispatch routing as a middleware.

If no route is found, the `$handler` will be used to generate the response.

### Router::handle($request)

Dispatch routing for a request.

If no route is found, a response with a HTTP 404 status will be returned.

If a route is found, but it does not allow the request method, a response with
a HTTP 405 will be returned.

## Credits

Borrows some ideas from [zend-expressive-fastroute][zf-fastroute] for handling [reverse routing][zf-rr].

[zf-fastroute]: https://github.com/zendframework/zend-expressive-fastroute
[zf-rr]: https://github.com/zendframework/zend-expressive-fastroute/pull/32

repository: northwoods/router

gha_language: PHP

gha_license_id: NOASSERTION

repo_name: northwoods/router


text:
Yii 2 CREATE AND READ CSV FILE PROJECT
======================================

DIRECTORY STRUCTURE
-------------------
      assets/             contains assets definition
      commands/           contains console commands (controllers)
      config/             contains application configurations
      controllers/        contains Web controller classes
      mail/               contains view files for e-mails
      models/             contains model classes
      runtime/            contains files generated during runtime
      tests/              contains various tests for the basic application
      vendor/             contains dependent 3rd-party packages
      views/              contains view files for the Web application
      web/                contains the entry script and Web resources

REQUIREMENTS
------------
The minimum requirement by this project that your Web server supports PHP 5.4.0.

INSTALLATION
------------
### Install from github repository
### Installation steps
1. git clone git@github.com:saralashrestha/clientSection.git to a directory that is directly under the Web root.
2. give write permission chmod 777 runtime/ -R
3. give write permission chmod 777 web/assets -R
4. give write permission chmod 777 upload -R

You can then access the application through the following URL:

~~~
http://localhost/clientSection/web/
~~~

FILES USED
-------------
    models/ContactForm.php
    controllers/SiteController.php
    views/
        site/index.php
        site/client.php
        site/error.php
    upload (the directory folder where csv file gets stored)

DEMO
-----------
1. Go to http://localhost/clientSection/web/
2. Add client.
3. Click on client list to view the client detail.
4. Client information is saved as client.csv on upload folder.

repository: saralashrestha/clientSection

repo_name: saralashrestha/clientSection


text:
# Municipal Agents for the Elderly Listing

## Dataset

| Name | Value |
| :--- | :---- |
| Catalog | [Link](https://catalog.data.gov/dataset/municipal-agents-for-the-elderly-listing) |
| Metadata | [Link](https://data.ct.gov/api/views/dsrn-u9nm) |
| Data: JSON | [100 Rows](https://data.ct.gov/api/views/dsrn-u9nm/rows.json?max_rows=100) |
| Data: CSV | [100 Rows](https://data.ct.gov/api/views/dsrn-u9nm/rows.csv?max_rows=100) |
| Host | data.ct.gov |
| Id | dsrn-u9nm |
| Name | Municipal Agents for the Elderly Listing |
| Attribution | Department on Aging |
| Category | Health and Human Services |
| Tags | elederly, seniors, aging |
| Created | 2014-04-03T14:00:03Z |
| Publication Date | 2014-08-01T17:55:38Z |

## Description

Listing of Department on Aging Municipal Agents for the Elderly

## Columns

```ls
| Included | Schema Type | Field Name  | Name       | Data Type | Render Type |
| ======== | =========== | =========== | ========== | ========= | =========== |
| No       | time        | :updated_at | updated_at | meta_data | meta_data   |
| Yes      | series tag  | first_name  | First Name | text      | text        |
| Yes      | series tag  | last_name   | Last Name  | text      | text        |
| Yes      | series tag  | agency      | Agency     | text      | text        |
| No       |             | address     | Address    | text      | text        |
| Yes      | series tag  | city_town   | City/Town  | text      | text        |
| No       |             | st          | ST         | text      | text        |
| Yes      | series tag  | zip_code    | Zip Code   | text      | text        |
| Yes      | series tag  | phone       | phone      | text      | text        |
| Yes      | series tag  | fax         | fax        | text      | text        |
| Yes      | series tag  | e_mail      | e-mail     | text      | text        |
| Yes      | series tag  | region      | Region     | text      | number      |
| Yes      | series tag  | none        | (none)     | text      | text        |
```

## Time Field

```ls
Value = updated_at
Format & Zone = seconds
```

## Series Fields

```ls
Excluded Fields = address,st
```

## Data Commands

```ls
series e:dsrn-u9nm d:2014-08-01T10:53:40.000Z t:first_name="Remove Edward Slattery from List" m:row_number.dsrn-u9nm=1

series e:dsrn-u9nm d:2014-08-01T10:53:40.000Z t:city_town="Ledyard (Gales Ferry)" t:region=3 t:first_name=Lauren t:phone="(860) 464-0471" t:fax="(860) 464-2124" t:zip_code=00635 t:last_name=Rapp<EMAIL_ADDRESS>t:agency="Ledyard Senior Center" m:row_number.dsrn-u9nm=2

series e:dsrn-u9nm d:2014-08-01T10:54:00.000Z t:city_town=Hartford t:region=4 t:first_name=Elby t:phone="(860) 757-4796" t:fax="(860) 723-8528" t:zip_code=06112 t:last_name=Gonzalez-Schwapp<EMAIL_ADDRESS>t:agency="Health and Human Services" m:row_number.dsrn-u9nm=3
```

## Meta Commands

```ls
metric m:row_number.dsrn-u9nm p:long l:"Row Number"

entity e:dsrn-u9nm l:"Municipal Agents for the Elderly Listing" t:attribution="Department on Aging" t:url=https://data.ct.gov/api/views/dsrn-u9nm

property e:dsrn-u9nm t:meta.view v:id=dsrn-u9nm v:category="Health and Human Services" v:averageRating=0 v:name="Municipal Agents for the Elderly Listing" v:attribution="Department on Aging"

property e:dsrn-u9nm t:meta.view.license v:name="Public Domain"

property e:dsrn-u9nm t:meta.view.owner v:id=cvy9-n6sb v:screenName="Tyler Kleykamp" v:lastNotificationSeenAt=1492608796 v:displayName="Tyler Kleykamp"

property e:dsrn-u9nm t:meta.view.tableauthor v:id=cvy9-n6sb v:screenName="Tyler Kleykamp" v:roleName=administrator v:lastNotificationSeenAt=1492608796 v:displayName="Tyler Kleykamp"
```

## Top Records

```ls
| :updated_at | first_name                       | last_name        | agency                     | address            | city_town             | st | zip_code | phone          | fax            | e_mail                              | region | none |
| =========== | ================================ | ================ | ========================== | ================== | ===================== | == | ======== | ============== | ============== | =================================== | ====== | ==== |
|<PHONE_NUMBER>  | Remove Edward Slattery from List |                  |                            |                    |                       |    |          |                |                |                                     |        |      |
|<PHONE_NUMBER>  | Lauren                           | Rapp             | Ledyard Senior Center      | 12 Van Tassell Dr  | Ledyard (Gales Ferry) | CT | 00635    |<PHONE_NUMBER> |<PHONE_NUMBER> |<EMAIL_ADDRESS>     | 3      |      |
|<PHONE_NUMBER>  | Elby                             | Gonzalez-Schwapp | Health and Human Services  | 2 Holcomb St.      | Hartford              | CT | 06112    |<PHONE_NUMBER> |<PHONE_NUMBER> |<EMAIL_ADDRESS>      | 4      |      |
|<PHONE_NUMBER>  | Kerry Ann                        | Kielbasa         | Granby Senior Center       | 15 North Granby Rd | Granby                | CT | 06035    |<PHONE_NUMBER> |<PHONE_NUMBER> |<EMAIL_ADDRESS>           | 4      |      |
|<PHONE_NUMBER>  | Heather                          | Castrilli        | Madison Senior Center      | 29 Bradley Road    | Madison               | CT | 06443    |<PHONE_NUMBER> |<PHONE_NUMBER> |<EMAIL_ADDRESS>          | 2      |      |
|<PHONE_NUMBER>  | Judith                           | Amarone          | Joyce Budrow Senior Center | 189 Pool Rd        | North Haven           | CT | 06473    |<PHONE_NUMBER> |<PHONE_NUMBER> |<EMAIL_ADDRESS>| 2      |      |
|<PHONE_NUMBER>  | Lucy                             | Smegielski       | Prospect Senior Center     | 6 Center St        | Prospect              | CT | 06712    |<PHONE_NUMBER> |<PHONE_NUMBER> |<EMAIL_ADDRESS>           | 5      |      |
|<PHONE_NUMBER>  | Melba                            | Neville          | Dept. of Human Serv.       | 77 Main St         | New Canaan            | CT | 06840    |<PHONE_NUMBER> |<PHONE_NUMBER> |<EMAIL_ADDRESS> | 1      |      |
|<PHONE_NUMBER>  | Joel                             | Sekorski         | Sullivan Senior Center     | 88 East Albert St  | Torrington            | CT | 06790    |<PHONE_NUMBER> |<PHONE_NUMBER> |<EMAIL_ADDRESS>    | 5      |      |
|<PHONE_NUMBER>  | Susan                            | Consoli          | Old Saybrook Town Hall     | 322 Main St.       | Old Saybrook          | CT | 06475    |<PHONE_NUMBER> |<PHONE_NUMBER> |<EMAIL_ADDRESS>  | 3      |      |
```

repository: SpellarBot/open-data-catalog

repo_name: SpellarBot/open-data-catalog


text:
# Calendarium

(C) 2021 Crowdcode GmbH+Co.KG

## Abstract

This is Calendarium, a free easy-to-use, multi-purpose utility for handling recurring entries inside
a temporal context.

## License

This utility is shipped under Apache License 2.0

## Usage

There are multiple ways to cope with the Event classes; instantiate the interface (e.g. when you make use of persistent
beans) or make use of the default implementation (located under impl), which come as value objects (final properties).
The decision logic to determine a due event has been put into strategy objects.

The CalendarEvent will determine the matching event handling strategy and check for due using this object.

### For the unpatient

#### instantiate the events and give it to the Calendarium

```
final LocalDateTime NOW = LocalDateTime.now();
final LocalDateTime firstDayOfYear = LocalDateTime.of(NOW.getYear(), 1, 1, 0, 0);
final LocalDateTime nextYear = NOW.plus(1, ChronoUnit.YEARS);
final CalendarEvent twoMonthEvent = new TwoMonthlyEventImpl(UUID.randomUUID(), CalendarEvent.Precision.DATE, "Two Event", "Test Event Weekly", NOW, firstDayOfYear, nextYear);
Calendarium probe1 = new Calendarium(twoMonthEvent);
```

#### get you stuff done by calendarium

```
EventMap result = probe1.createCalendar(LocalDate.now(), LocalDate.now().plus(1, ChronoUnit.YEARS), true);
List<CalendarEvent> todaysEvents = result.get(NOW.toLocalDate());
```

For more details check CalendariumTest class

repository: crowdcode-de/calendarium-core

branch_name: refs/heads/develop

repo_name: crowdcode-de/calendarium-core


text:
[![Build Status](https://travis-ci.org/YannBrrd/elasticsearch-entity-resolution.svg?branch=master)](http://travis-ci.org/YannBrrd/elasticsearch-entity-resolution)

elasticsearch-entity-resolution
===================

This project is an interactive entity resolution plugin for [Elasticsearch](http://www.elasticsearch.org) based on [Duke](http://github.com/larsga/Duke). Basically, it uses [Bayesian probabilities] (http://en.wikipedia.org/wiki/Bayesian_probability) to compute probability. You can pretty much use it as an interactive deduplication engine.

To understand basics, go to [Duke project documentation](https://github.com/larsga/Duke/wiki/XMLConfig).

A list of [available comparators] (https://github.com/larsga/Duke/wiki/Comparator) is available [here](https://github.com/larsga/Duke/wiki/Comparator).

### Documentation

[FAQ](http://github.com/YannBrrd/elasticsearch-entity-resolution/wiki/FAQ)

[How to install](http://github.com/YannBrrd/elasticsearch-entity-resolution/wiki/install)

[Configuring the plugin](http://github.com/YannBrrd/elasticsearch-entity-resolution/wiki/configure)

[Caveats](http://github.com/YannBrrd/elasticsearch-entity-resolution/wiki/caveats)

[Going to indus mode](http://github.com/YannBrrd/elasticsearch-entity-resolution/wiki/indus)

[Run examples](http://github.com/YannBrrd/elasticsearch-entity-resolution/wiki/Run-Examples)

[Contact](http://github.com/YannBrrd/elasticsearch-entity-resolution/wiki/contact)

[Credits](http://github.com/YannBrrd/elasticsearch-entity-resolution/wiki/credits)

[What else ?](http://github.com/YannBrrd/elasticsearch-entity-resolution/wiki/what_else)

## Licence

This project is licended under APL V2

Copyright (c) 2014 Yann Barraud

repository: mfarid/elasticsearch-entity-resolution

repo_name: mfarid/elasticsearch-entity-resolution


text:
# Using Bolt.Sips to query the Neo4j server

Let's talk about the basics of querying a Neo4j server, using `Bolt.Sips`, and a few methods you could use for using the data returned by the server, using the `Bolt.Sips.Response`. You can learn so much more from the official docs, available at [Neo4j](https://neo4j.com/developer/graph-database/), you should start from there, if you want to get a deep understanding about the Neo4j graph database and its query language: Cypher.

## What you need?

- a [Neo4j](https://neo4j.com/download/) server running locally and available at this `url`: `bolt://neo4j:test@localhost`
- a mix project with `:bolt_sips` available

## Simple queries, using Cypher

With the above prerequisites, let's drop into the IEx shell and start experimenting.

```sh
cd my_neo4j
iex -S mix
Erlang/OTP 21 [erts-10.2.3] [source] [64-bit] [smp:8:8] [ds:8:8:10] [async-threads:1] [hipe]

Interactive Elixir (1.8.1) - press Ctrl+C to exit (type h() ENTER for help)

iex»
```

First we need to start the driver with a minimalist configuration (unless it is already started by your project?):

```elixir
iex» {:ok, _neo} = Bolt.Sips.start_link(url: "bolt://neo4j:test@localhost")
{:ok, #PID<0.243.0>}
iex»

```

Presuming your database is empty, you can still test your setup by running a simple Cypher query:

```elixir
iex» conn = Bolt.Sips.conn()
#PID<0.248.0>
iex» Bolt.Sips.query!(conn, "RETURN 1 as n") |>
...» Bolt.Sips.Response.first()
%{"n" => 1}
```

and we obtained our first response from the server: `%{"n" => 1}`, w⦿‿⦿t!! Now let's try some more complicated Cypher queries. We'll use examples that you may want to paste them in your `.exs/.ex` files rather than into the IEx shell, for readability.

While most of the Cypher querier fit on a simple row, and they look compact, you might encounter situations where you need to send multiple queries in a single trip, to the server. `Bolt.Sips` allows you do that.

Let's initialize our **test** database with some data.

```elixir
cypher = """
  CREATE (BoltSips:BoltSips {title:'Elixir sipping from Neo4j, using Bolt', released:2016, license:'MIT', bolt_sips: true})
  CREATE (TNOTW:Book {title:'The Name of the Wind', released:2007, genre:'fantasy', bolt_sips: true})
  CREATE (Patrick:Person {name:'Patrick Rothfuss', bolt_sips: true})
  CREATE (Kvothe:Person {name:'Kote', bolt_sips: true})
  CREATE (Denna:Person {name:'Denna', bolt_sips: true})
  CREATE (Chandrian:Deamon {name:'Chandrian', bolt_sips: true})

  CREATE
    (Kvothe)-[:ACTED_IN {roles:['sword fighter', 'magician', 'musician']}]->(TNOTW),
    (Denna)-[:ACTED_IN {roles:['many talents']}]->(TNOTW),
    (Chandrian)-[:ACTED_IN {roles:['killer']}]->(TNOTW),
    (Patrick)-[:WROTE]->(TNOTW)
"""

{:ok, response} =
  Bolt.Sips.conn()
  |> Bolt.Sips.query(cypher)
```

According to the response from the server, this is what we did:

```elixir
iex» response
%Bolt.Sips.Response{
  results: [],
  stats: %{
    "labels-added" => 6,
    "nodes-created" => 6,
    "properties-set" => 19,
    "relationships-created" => 4
  },
  type: "w"
}
```

we have 6 new Nodes, 6 new labels and 4 new relationships.

At any time, if you want to clean up the data we're creating, you can use this query:

`MATCH (n {bolt_sips: true}) OPTIONAL MATCH (n)-[r]-() DELETE n,r`

Observe we're adding a `bolt_sips` property to the Nodes we're adding, so that it's easier to refer them in our tests.

Let's see how many nodes of "type" (`label`, according to Cypher's official terminology) `Person` having the property `bolt_sips` true, we have in our database:

```elixir
iex» query = """
...»   MATCH (n:Person {bolt_sips: true})
...»   RETURN n.name AS Name
...»   ORDER BY Name DESC
...»   LIMIT 5
...»  """

iex» %Bolt.Sips.Response{} = response = Bolt.Sips.query!(conn, query)
%Bolt.Sips.Response{
  bookmark: "neo4j:bookmark:v1:tx21613",
  fields: ["Name"],
  notifications: [],
  plan: nil,
  profile: nil,
  records: [["Patrick Rothfuss"], ["Kote"], ["Denna"]],
  results: [
    %{"Name" => "Patrick Rothfuss"},
    %{"Name" => "Kote"},
    %{"Name" => "Denna"}
  ],
  stats: [],
  type: "r"
}
```

We have 3 of them, and we're only showing the `name` property! Above you see the full `Bolt.Sips.Response` returned by our driver based on the raw data returned by the Neo4j server. The `:results` key, contains the aggregated response you will use most of the time, and for that the `Bolt.Sips.Response` module has some useful helpers, for example:

```elixir
iex» response |>
...» Bolt.Sips.Response.first()
%{"Name" => "Patrick Rothfuss"}
```

and much more. Check the `Bolt.Sips.Response`'s own docs, for more.

gha_language: Elixir


text:
Contribution Type: bug fix | new plugin | new feature | refactor | cosmetic
Link to Intent to Implement:
Link to Bug:

This pull request affects the following areas:

* [ ] Front-End
* [ ] Builder
* [ ] Build Plugins

**In raising this pull request, I confirm the following (please check boxes):**

- [ ] I have read and understood the [contributing guidelines](/.github/CONTRIBUTING.md)?
- [ ] I have checked that another pull request for this purpose does not exist.
- [ ] I have considered, and confirmed that this submission will be valuable to others.
- [ ] I have created or updated the relevant documentation for this change on the PHPCI Wiki.
- [ ] Do the PHPCI tests pass?

Detailed description of change:


text:
# CommonDataModelMapper

Scripts, utility functions, and classes for mapping data to a common data model (CDM).
The primary target of this project is the CDM associated with the OHDSI/OMOP project. More
detail on the OHDSI project can be found here: https://www.ohdsi.org/.

repository: jhajagos/CommonDataModelMapper

repo_name: jhajagos/CommonDataModelMapper


text:
# Publishing data into an Amazon Kinesis Stream with the AWS SDK for .NET

## Overview

This walk-through illustrates how to use Amazon Kinesis from .NET applications using the [AWS SDK for .NET](https://docs.aws.amazon.com/sdk-for-net/). The walk-through will use the AWS Management Console to make a Kinesis Data Stream. Next, we’ll create a new .NET console application and add the AWS SDK for Kinesis to use it. The sample application will run like simulated IoT devices which are sending temperature and humidity values collected from their sensors into the Amazon Kinesis stream. Finally, we will use Amazon Kinesis Data Analytics to aggregate average temperature values in real-time.

* Links to documentation

  * [Amazon Kinesis](https://aws.amazon.com/kinesis/)
  * [Amazon Kinesis Data Streams](https://aws.amazon.com/kinesis/data-streams/)
  * [Amazon Kinesis Data Streams Developer Guide](https://docs.aws.amazon.com/streams/latest/dev/)
  * [Amazon Kinesis Data Streams API Reference](https://docs.aws.amazon.com/kinesis/latest/APIReference/)
  * [Amazon Kinesis Data Analytics](https://aws.amazon.com/kinesis/data-analytics/)
  * [Amazon Kinesis Data Analytics Developer Guide](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/)
  * [AWS Kinesis Data Analytics SQL Reference](https://docs.aws.amazon.com/kinesisanalytics/latest/sqlref/)

### Prerequisites

* .NET Core SDK 3.x ***or*** .NET Framework on Windows
  <https://www.microsoft.com/net/download/>
* Visual Studio 2019 or another IDE/editor suitable for working with C# code.
* AWS Account with credentials configured locally in the [AWS Toolkit for Visual Studio](https://aws.amazon.com/visualstudio/), or using the [AWS Tools for PowerShell](https://aws.amazon.com/powershell/) or the [AWS CLI](https://aws.amazon.com/cli/)\*

**AWS Experience:** Beginner\
**Time to Complete:** 1 hour\
**Cost to Complete:** Please note that Amazon Kinesis Data Streams and Amazon Kinesis Data Analytics are not currently available in AWS Free Tier.

* Amazon Kinesis Data Streams: in the US East (N. Virginia) region, one shard costs %0.015 per hour or \$0.36 per day (\$0.015\*24)\*.
* Amazon Kinesis Data Analytics: you pay only for what you use. You are charged an hourly-rate based on the average number of Kinesis Processing Units (or KPUs) used to run your stream processing application. In the US East (N. Virginia) region, one KPU costs \$0.110 per hour\*\*.

\* Accounts that have been created within the last 24 hours might not yet have access to the resources required for this walk-through.\
\*\*Refer to <https://aws.amazon.com/kinesis/data-streams/pricing/>

## Introduction

Amazon Kinesis makes it easy to collect, process, and analyze real-time, streaming data so you can get timely insights and react quickly to new information. Amazon Kinesis offers key capabilities to cost-effectively process streaming data at any scale, along with the flexibility to choose the tools that best suit the requirements of your application.

The sample application developed in the walk-through will use a .NET console application configured with the appropriate NuGet packages to support calling Amazon Kinesis service APIs from the AWS SDK for .NET. The sample application will simulate IoT devices that are sending temperature and humidity values collected from their sensors into a Kinesis stream. Kinesis Data Analytics will be used to aggregate average temperature and humidity values every 10 seconds.

### Application Architecture

The application architecture uses AWS Kinesis Data Streams to receive stream data published from our .NET application. It uses Amazon Kinesis Data Analytics to aggregate stream data in real time as pictured below.

![Architecture](media/image1.png)

### Modules

This workshop is broken up into four modules. You must complete each module before proceeding to the next.

1. Amazon Kinesis Data Stream Creation

1. IAM User Setup

1. Create a .NET Console Application

1. Create a Kinesis Analytics Application

1. Clean Up

## Module 1: Amazon Kinesis Data Stream Creation

In this module you will set up an Amazon Kinesis Data Streams for the .NET sample application, which you will implement in module two.

**Time to complete:** 5 minutes

### Step 1: Select a Region

Log into the AWS Management Console and select a region to create in which to create an Amazon Kinesis Stream by using the region selector. You can select any AWS region that supports the Amazon Kinesis Streams service. This walk-through will default to using US East (N. Virginia) by default.

### Step 2: Create a Kinesis stream

1. In the AWS Management Console click **Services**.

1. Select *Kinesis* under *Analytics*.

1. Ensure that the *Kinesis Data Streams* radio button is selected

2. Click the **Create data stream** button in the *Get started* section.

3. In the *Create a data stream* page that is displayed:
    1. Type a name for your Kinesis stream name
    2. Type a number for Number of shards
    3. Click the **Create data stream** button.

    ![Create stream](media/image2.png)

    > **Note:** Be sure to remember or make a note of the Kinesis stream name you have chosen. It will be required in module 3.

Once created, the Status value will be changed to Active in a few seconds:

![Active status](media/image3.png)

## Module 2: IAM User Setup

In this module you will set up an IAM User and configure permissions to permit access to the data stream you have just created.

**Time to complete:** 15 minutes

### Step 1: Create a policy

1. In the AWS Management Console click **Services**.

1. Select *IAM* under *Security, Identity & Compliance*.

1. In the navigation pane select *Policies* and then click the **Create policy** button.

1. Click **Choose a service** and select *Kinesis* from the list.

1. In the *Actions* section, select **Write** for *Access level*.

    ![Actions](media/image4.png)

1. Expand the *Resources* section and click the **Specific** radio button.

1. For **stream** click the **Add ARN to restrict access** link.

1. Enter the name of the stream you created in the *Stream name* field.

    ![Specify ARN](media/image5.png)

1. Click the **Review policy** button.

2. Enter a name for the policy and then click the **Create policy** button.

    ![Policy review](media/image6.png)

### Step 2: Add an IAM user

The IAM user we add in this section will be used exclusively in our console sample application to forward the data from our imaginary sensors into our stream.

1. In the IAM Management Console select *Users* in the navigation pane.

1. Click the **Add user** button.

1. Enter a name for your user in the *User name* field.

1. In the *Select AWS access type* section. check **Programmatic access**. We do not need console access for this user so leave that option unchecked.

    ![IAM User](media/image7.png)

1. Click the **Next: Permissions** button.

1. Select the **Attach existing policies directly** option.

1. In the *Filter policies* search field, enter the name of the policy you created in the previous step. Click the checkbox next to the policy that is listed to select it.

    ![User permissions](media/image8.png)

1. Click the **Next: Tags** button.

1. Attaching tags to resources is considered a good practice but is out of scope for this walk-through so click the **Next: Review** button.

1. Review the user information and then click the **Create user** button.

1. The console will now display the programmatic access and secret keys for the new user user. The secret key will be maked by default. Programmatic keys look like this:

    * Access key ID:\
      *<REDACTED_AWS_ACCESS_KEY>*
    * Secret access key: (click **Show** to display)\
      *wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY*

> **Note:**
>
> This is the **only** time you will be able to view the secret access key for this user. Be sure to download the CSV file containing the credentials, or make a note of them as we will need them later in this walk-through.
>
> **Always keep the keys confidential to protect your AWS account and never share or email them.**

To complete this step ensure you have saved or noted the generated credentials and then click **Close**.

### Step 3: Set up an AWS Credential Profile for our sample application

In this step we will create a credential profile that will be used to supply the programmatic credentials we created in step 2 to the AWS SDK for .NET in our application code.

> Note: the instructions in this step create a credential profile with the name *default*. If you have already used any of the AWS tools and SDKs for developers on your local system you may already have a credential profile with this name and may want to consider using a different name or mechanism to supply credentials to your application code. See <https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/net-dg-config-creds.html> for more in-depth details on how credentials can be supplied to your application.

To set up a credential profile you can use either the [AWS Tools for PowerShell](https://aws.amazon.com/powershell/), [AWS CLI](https://aws.amazon.com/cli/) or the [AWS Toolkit for Visual Studio](https://aws.amazon.com/visualstudio/). The instructions below focus on using the command line tools. Refer to the toolkit's [user guide](https://docs.aws.amazon.com/toolkit-for-visual-studio/latest/user-guide/credentials.html) for instructions on how to set up credential profiles inside Visual Studio.

#### 3.1: Set up a credential profile using the AWS Tools for PowerShell

* Users on Windows running PowerShell versions 2 through 5.x should install the AWS Tools for Windows PowerShell module:
    <https://www.powershellgallery.com/packages/AWSPowerShell/>

* Users on Windows, Mac, or Linux running PowerShell version 6.x should install the AWS Tools for PowerShell Core module:
    <https://www.powershellgallery.com/packages/AWSPowerShell.NetCore/>

Once the correct module for your version of PowerShell is installed you can configure the tools by opening a PowerShell shell and running the following commands:

```powershell
PS C:\> Import-Module AWSPowerShell # replace with AWSPowerShell.NetCore on PowerShell version 6 or higher
PS C:\> Set-AWSCredential -AccessKey "ACCESS-KEY-HERE" -SecretKey "SECRET-KEY-HERE" -StoreAs "default"
```

For more information on configuring the AWS Tools for PowerShell please refer to the [user guide](https://docs.aws.amazon.com/powershell/latest/userguide/pstools-welcome.html).

#### 3.2: (Alternative) Set up a credential profile with the AWS CLI

1. Install the AWS CLI for Windows, Mac, or Linux:
    <https://aws.amazon.com/cli/>

1. Once installed, you can configure the CLI by running the `aws configure` command in a terminal or command-line window.

1. When prompted, enter your AWS Access Key ID and press **Return**.

1. Enter your AWS Secret Access Key when prompted and then press **Return**.

1. For the default region name you should enter your chosen region code (e.g. eu-west-1)

1. Finally, for the default output format you can just press **Return**.

## Module 3. Create a .NET Console Application

In this module you will create and configure a .NET console application to publish data into the Amazon Kinesis Data Stream we created in step 1.

*Time to complete*: 20 minutes

### Step 1. Create an empty console application project

Our sample application for this walk-through is a console application that can be created using either the .NET Framework (on Windows) or .NET Core (on Windows, MacOS or Linux). The included application code is based on .NET Core.

The instructions below assume you are using .NET Core and the dotnet CLI tools to create and manage the project. If you are using Visual Studio on Windows you can use the IDE's *File > New Project* wizard to create the application and the NuGet tools within Visual Studio to add the necessary dependencies.

#### 1.1: Create the sample project

1. Open a shell or command line prompt.

1. Create a folder for the new project and `cd` into it, then run the dotnet CLI command to create a new console application:

```bash
mkdir kinesis-sample
cd kinesis-sample
dotnet new console
```

#### 1.2: Add NuGet Dependencies

In this step we will add the necessary NuGet packages for the AWS SDK for .NET to enable our application to make calls to Kinesis. The instructions below assume use of the dotnet CLI in a .NET Core based application; if you are using the .NET Framwork, or Visual Studio, you can add the dependencies via the *Manage NuGet Packages...* option on the project menu or the NuGet Package Manager console.

1. Add a dependency on the [AWSSDK.Kinesis](https://www.nuget.org/packages/AWSSDK.Kinesis/) NuGet package:

```bash
dotnet add package AWSSDK.Kinesis
```

1. Add a dependency on the [Newtonsoft.Json](https://www.nuget.org/packages/Newtonsoft.Json/) package (this is an additional dependency required by our application code, not the AWS SDK):

```bash
dotnet add package Newtonsoft.Json
```

### Step 2: Write the C# Code

> Note: The completed sample application can be found in the SampleApplication subfolder of this guide.

1. In Visual Studio or an editor of your choice, open the *Program.cs* file.

1. Replace the generated sample code with the following. The sample code simulates  IoT devices that are sending temperature and humidity values collected from their sensors into our Kinesis Data Stream:

    ```csharp
    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Text;
    using System.Threading;
    using Amazon.Kinesis;
    using Amazon.Kinesis.Model;
    using Newtonsoft.Json;

    namespace KinesisPublishSample
    {
        public class DeviceData
        {
            public string DeviceId { get; set; }
            public int Humidity { get; set; }
            public int Temperature { get; set; }
        }

        class Program
        {
            // NOTE: replace the value with your Kinesis stream name
            static string _kinesisStreamName ="YOUR-KINESIS-STREAM-NAME-HERE";

            // NOTE: update with the region in which you created your stream
            static Amazon.RegionEndpoint _regionEndpoint = Amazon.RegionEndpoint.USEast1;

            static int _maxExecutionCount = 1000;
            static int _publishInterval = 3000;
            static int _deviceCount = 5;

            static bool _cancelled = false;

            static void Main(string[] args)
            {
                Console.WriteLine($"Now ready to publish data into Kinesis stream : {_kinesisStreamName}\n");
                Console.WriteLine("Press Ctrl+C to exit...\n");

                Console.CancelKeyPress += new ConsoleCancelEventHandler(Console_CancelKeyPress);

                for (var i = 0; i < _maxExecutionCount; i++)
                {
                    List<DeviceData> dataList = GetDeviceData();
                    PublishDeviceDataToKinesis(dataList);
                    Thread.Sleep(_publishInterval);

                    if (_cancelled) break;
                }

                Console.WriteLine("Task Completed!\n");
                Console.Write("To publish more data, please run the application again.\n");

                Console.CancelKeyPress -= new ConsoleCancelEventHandler(Console_CancelKeyPress);
            }

            private static void Console_CancelKeyPress(object sender, ConsoleCancelEventArgs e)
            {
                if (e.SpecialKey == ConsoleSpecialKey.ControlC)
                {
                    _cancelled = true;
                    e.Cancel = true;
                }
            }

            private static void PublishDeviceDataToKinesis(List<DeviceData> dataList)
            {
                // note: this constructor relies on you having set up a credential profile
                // named 'default', or have set credentials in environment variables
                // AWS_ACCESS_KEY_ID & AWS_SECRET_ACCESS_KEY, or have an application settings
                // file. See https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/net-dg-config-creds.html
                // for more details and other constructor options.
                var kinesisClient = new AmazonKinesisClient(_regionEndpoint);

                foreach (DeviceData data in dataList)
                {
                    var dataAsJson = JsonConvert.SerializeObject(data);
                    var dataAsBytes = Encoding.UTF8.GetBytes(dataAsJson);
                    using (var memoryStream = new MemoryStream(dataAsBytes))
                    {
                        try
                        {
                            var requestRecord = new PutRecordRequest
                            {
                                StreamName = _kinesisStreamName,
                                PartitionKey = data.DeviceId,
                                Data = memoryStream
                            };

                            var responseRecord = kinesisClient.PutRecordAsync(requestRecord).Result;
                            Console.WriteLine($"Successfully published. Record:{data.DeviceId},{data.Humidity},{data.Temperature} Seq:{responseRecord.SequenceNumber}");

                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine($"Failed to publish. Exception: {ex.Message}");
                        }
                    }
                }
            }

            private static List<DeviceData> GetDeviceData()
            {
                var dataList = new List<DeviceData>();

                var url = Path.GetRandomFileName();
                for (var i = 0; i < _deviceCount; i++)
                {
                    var rnd = new Random(Guid.NewGuid().GetHashCode());

                    var data = new DeviceData
                    {
                        DeviceId = string.Format("Device{0}", i),
                        Temperature = rnd.Next(0, 40),
                        Humidity = rnd.Next(0, 100)
                    };

                    dataList.Add(data);
                }
                return dataList;
            }
        }
    }
    ```

1. Replace *YOUR-KINESIS-STREAM-NAME-HERE* with the name of your actual Kinesis stream that was created in module 1.

1. If your Kinesis stream was created in a region other than US East (N. Virginia), update the value of the _regionEndpoint as appropriate.

    > *Note:* Amazon Kinesis is a regional service. If you try to access a Kinesis stream in another region, you will get a 'stream not found' error.

***Additional notes***

* The sample code will run 1000 times. You can change the value by modifying the *_maxExecutionCount* variable.
* The sample will publish data every 3 seconds. You can change the interval by modifying the *_publishInterval* variable.
* The sample will simulate 5 IoT devices. You can change the device count by modifying the *_deviceCount* variable.

### Step 3: Test the application

1. In your shell command prompt execute the command `dotnet run` to build and run the application. In Visual Studio, press *F5*.

1. While the application runs it will output progress messages:

    ```bash
    Now ready to publish data into Kinesis stream : MyKinesisStream

    Press Ctrl+C to exit...

    Successfully published. Record:Device0,19,5 Seq:49593850145254330957453609702703505252154159559671283714
    Successfully published. Record:Device1,52,16 Seq:49593850145254330957453609702704714177973774188845989890
    Successfully published. Record:Device2,27,7 Seq:49593850145254330957453609702705923103793388818020696066
    Successfully published. Record:Device3,34,7 Seq:49593850145254330957453609702707132029613003447195402242

    ...
    Successfully published. Record:Device4,96,0 Seq:49593850145254330957453609702753071210758360798943248386
    Task Completed!

    To publish more data, please run the application again.
    ```

1. To see the status of the Kinesis stream, in the AWS Management Console navigate to the Kinesis dashboard <https://us-west-2.console.aws.amazon.com/kinesis/home>.

1. In the *Kinesis data streams* panel click on your stream name.

1. Select the *Monitoring* tab in the resulting view and scroll down until you see the *Put Record* graphs.

    ![Monitoring](media/image9.png)

## Module 4. Create a Kinesis Analytics application

Amazon Kinesis Data Analytics is the easiest way to process streaming data in real time with standard SQL without having to learn new programming languages or processing frameworks. In this module you will create and configure a Kinesis Analytics application to analyze stream data in real-time.

**Time to complete:** 15 minutes

### Step 1: Create a Kinesis Analytics application

1. In the AWS Management Console click **Services**.

1. Select *Kinesis* under *Analytics*.

1. In the navigation panel click **Data Analytics**.

1. Click **Create application**.

1. Enter a name for the application and then click the **Create application** button.

    ![Create application](media/image10.png)

### Step 2: Connect to source and discover schema

1. Click **Connect streaming data**.

1. On the *Connect streaming data source* page click **Choose source**.

1. Select **Kinesis stream** for *Source* and in the *Kinesis stream* drop-down select the name of the stream that was created in module 1.

    ![Connect data source](media/image11.png)

1. Scroll down and click the **Discover schema** button. Kinesis will then begin generating a schema from recent records from the source stream.

    ![Connect source](media/image12.png)

1. When schema discovery has completed you can see the formatted schema as below:

    ![Schema](media/image13.png)

1. Click the **Save and continue** button.

### Step 3: Configure Real-time Analytics

1. In the *Real time analytics* section click the **Go to SQL editor** button.

1. A pop-up dalog will be displayed asking if you want to start running the application. Click the **Yes, start application** button. Kinesis will start the application, which can take 30 seconds or so.

1. Copy and paste the following SQL queries into the SQL editor. For each query click the **Save and run SQL** button.

    ```sql
    CREATE OR REPLACE STREAM "DESTINATION_SQL_STREAM" (device_id VARCHAR(8), avg_humidity INTEGER, avg_temperature INTEGER);
    CREATE OR REPLACE PUMP "STREAM_PUMP" AS INSERT INTO "DESTINATION_SQL_STREAM"
    SELECT STREAM "DeviceId",
        AVG("Humidity") AS avg_humidity,
        AVG("Temperature") AS avg_temperature
        FROM "SOURCE_SQL_STREAM_001"
        GROUP BY "DeviceId", FLOOR(("SOURCE_SQL_STREAM_001".ROWTIME - TIMESTAMP '1970-01-01 00:00:00') SECOND / 10 TO SECOND);
    ```

    ![Sql1](media/image14.png)

1. The sample SQL script runs on the aggregate stream data over a 10 second tumbling window for Temperature and Humidity column.

1. You can see the analytic results from the **Real-time analytics**
    tab as below.

    ![Results1](media/image15.png)

    > Note: We used a simple aggregation function to get average temperature and humidity data from stream data received from devices. The following diagram illustrates the overall process.

    ![Overall process](media/image16.png)

    * *SOURCE STREAM* - a continuously updated entity that you can `SELECT` from and `INSERT` into like a `TABLE`
    * *PUMP* - an entity used to continuously `SELECT ... FROM` a source STREAM, and `INSERT` SQL results into an output STREAM
    * *OUTPUT STREAM* - used to send to a destination

To see more examples, please refer to the following article: [Example Amazon Kinesis Data Analytics Applications](https://docs.aws.amazon.com/kinesisanalytics/latest/dev/example-apps.html)

You can also connect an in-application stream to a Kinesis stream, or to a Firehose delivery stream, to continuously deliver SQL results to an AWS destination. For example, you can integrate with BI tools like QuickSight or other 3rd party visualization tools.

## Module 5. Cleanup

In this module you will clean up resources to avoid charges.

**Time to complete:** 5 minutes

### Step 1. Delete the Kinesis stream

1. Go to the **Kinesis** dashboard page in the AWS Management Console.

1. Click **Data Streams** in the navigation pane.

1. Check the box next to your Kinesis stream.

1. Click **Delete** button to delete the stream and follow directions on *Delete* confirmation screen.

### Step 2. Delete the Analytics application

1. Go to the **Kinesis** dashboard page in the AWS Management Console.

1. Click **Data Analysis** in the navigation pane.

1. Select the radio button next to your Kinesis Analytics application.

1. Select the *Actions* drop down menu.

1. Click **Delete Application**.

1. In the confirmation pop-up dialog click **Delete application** to confirm deletion.

Congratulations! You have completed this walk-through of how to publish data from a .NET application to Amazon Kinesis.

repository: aws-samples/aws-net-guides

gha_language: JavaScript

repo_name: aws-samples/aws-net-guides


text:
# Project Title
### README Generator

[![License: Unlicense](https://img.shields.io/badge/license-Unlicense-blue.svg)](http://unlicense.org/)

# Description
#### This is a project for generating a  README.md file that looks good from the command line using NODE.

## Table of Contents
* [Installation](#Installation)
* [Usage](#Usage)
* [License](#License)
* [Contributing](#Contribution)
* [Tests](#Tests)
* [Questions](#Contact)

## Installation
#### You just need to use Node.js so make sure you have that installed

## Usage
#### This can be used by anyone

## License
#### The Unlicence

## Contribution
#### Just ask!

### Tests
##### I haven't at present created any tests.

# Contact
### Github: [rickySulli](http://github.com/rickySulli)
### Email<EMAIL_ADDRESS>

license: Unlicense

repository: RickySulli/readme-generator

repo_name: RickySulli/readme-generator


text:
## Usage

- install Jekyll with `sudo gem install github-pages`
- run `jekyll serve -w`
  - visit [localhost:4000](http://localhost:4000) to see a live locally served preview.
- Push changes and see them live!

Please leave us a message on the [ethpm gitter channel](http://gitter.im/ethpm) if you'd like to see some changes to this website.

repository: ethpm/website

gha_language: CSS

repo_name: ethpm/website


text:
# Routing

Routing determines how the application responds to a request.

Let's use routes to create 2 new pages.

```javascript
app.get('/page1', (request, response) => {
    response.send("Page 1.")
})

app.get('/page2', (request, response) => {
    response.send("Page 2.")
})
```

We will be available at [http://localhost:8080/page1](http://localhost:8080/page1) and [http://localhost:8080/page2](http://localhost:8080/page2).

license: ISC

repository: dev-mission/node-backend-course

repo_name: dev-mission/node-backend-course


text:
waifu2x.go
===

[![experimental](http://badges.github.io/stability-badges/dist/experimental.svg)](http://github.com/badges/stability-badges)

Image super-resolution using deep convolutional neural network (CNN).
waifu2x.go is a clone of waifu2x-js.

waifu2x-js: https://github.com/takuyaa/waifu2x-js

Note
---

This software includes a binary and/or source version of model data from waifu2x
which can be obtained from https://github.com/nagadomi/waifu2x.

License
---

[MIT License](https://opensource.org/licenses/MIT)