text:
robotframework-selenium2library-extensions
==========================================
Extends the [robotframework-selenium2library](https://github.com/rtomac/robotframework-selenium2library/ "robotframework-selenium2library").

Extra keywords
==============

[Action Chains](http://selenium.googlecode.com/svn/trunk/docs/api/py/webdriver/selenium.webdriver.common.action_chains.html)
Lazily initiates an action chains.

    Chain Sleep
    Chain Click
    Chain Click And Hold
    Chain Drag And Drop
    Chain Key Up
    Chain Key Down
    Chain Move By Offset
    Chain Move To Element
    Chain Move To Element With Offset
    Chain Release
    Chain Send Keys
    Chain Send Keys To Element

Execute the created action chains:

    Chains Perform Now

Drag and drop shortcuts: immediately performed.

    Drag And Drop
    Drag And Drop With Offset

Page Tests:

    Select IFrame
    Is Element Present
    Is Visible

Note: some limitations regarding drag and drop
==============================================
Note that action chains are not well supported by some dirvers.
In particular, HTML5 Drag and Drop have not worked so far for firefox and chrome
on my linux machine.
It is working with jquery's drag and drop.

Here are some notable webkit and chrome-driver bugs to follow:
* keyup can't be simulated: (https://bugs.webkit.org/show_bug.cgi?id=16735)
* html5's drag and drop with chrome-driver not supported: (http://code.google.com/p/selenium/issues/detail?id=3604)

Requirements
============
* Robotframework
* robotframework-selenium2library

Installation
============

    git clone https://github.com/hmalphettes/robotframework-selenium2library-extensions.git

And in your robotframework test, import the library. For example:

    *** Settings
    Library           ${CURDIR}/../../src/Selenium2LibraryExtensions    WITH NAME    Selenium2LibraryExtensions

Run the tests
=============

    ./test/run_tests.sh

Extending robotframework-selenium2library without forking it
============================================================
Use any of the techniques documented to write a python plugin for robotframework.
In your keyword's method here how to access the active selenium's browser:

   selenium2lib = BuiltIn().get_library_instance('Selenium2Library')
   selenium_browser = selenium2lib._current_browser()

Now refer to selenium driver's python API and go wild.

License
=======
ASL-2.0 just like robotframework-selenium2library.

extension: markdown


text:
## Solarwinds Owner Update

This script allows you to update users based on a username formula.
For example if the username on the hardware record is 'john.doe' it will assign the record to<EMAIL_ADDRESS>
##### Before you start

1. Install ruby
2. Clone this repo and `bundle` or download the file `update-hardware-owners-by-username.rb` and type `gem install samanage parallel`

3. Edit script with your email domain here

```ruby
  #...
  api_token = ARGV[0]
  @samanage = Samanage::Api.new(token: api_token)
  # Edit Below
  @email_domain =<EMAIL_ADDRESS>  #...
```

##### To Run

`ruby update-hardware-owners-by-username.rb API_TOKEN`

license: MIT

url: https://raw.githubusercontent.com/dmoore68/Samples/8bdea83567d92fa4aeede517456fc273291f8627/Populate Hardware Owners/Populate Owners By Username/readme.md

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
# This Repository is Unmaintained

As of 2021 this repo has been unmaintained due to the existence of Vite and [vite-ts-tailwind-starter](https://github.com/Uninen/vite-ts-tailwind-starter). You should use either an official vue-cli template or the Vite starter (which has the same but upgraded and maintained features) instead of this one.

----

![check-code-coverage](https://gitlab.com/uninen/vue-cli-template/badges/trunk/coverage.svg)

This repository is [hosted at GitLab](https://gitlab.com/uninen/vue-cli-template/) and mirrored to GitHub.

# Opinionated Vue CLI Template

- Vue 3
- Vue router
- Vuex
- TypeScript
- Tailwind CSS 2.0 w/ plugins
  - `@tailwindcss/aspect-ratio`
  - `@tailwindcss/typography`
  - `@tailwindcss/forms`
- Cypress.io e2e tests (w/ coverage)
- GitLab CI
  - Run tests on push
- Github Actions
  - Run tests on push
  - Run Dependabot weekly

## Project setup

```
yarn install
```

### Starts development server

```
yarn dev
```

### Compiles and minifies for production

```
yarn build
```

### Run your end-to-end tests

```
yarn test:e2e
```

### Lints and fixes files

```
yarn lint
```

### Customize configuration

See [Configuration Reference](https://cli.vuejs.org/config/).

repository: Uninen/vue-cli-template

branch_name: refs/heads/trunk

gha_language: JavaScript

gha_license_id: MIT

repo_name: Uninen/vue-cli-template


text:
# Github Trending App [![Build Status](https://travis-ci.org/huangyanxiong01/Github-Trending-App.svg?branch=master)](https://travis-ci.org/huangyanxiong01/Github-Trending-App)

Github Trending app built with [Flutter](https://github.com/flutter)

## Build

Clone code to local

```
git clone git@github.com:huangyanxiong01/Github-Trending-App.git
```

Get packages from dart pub site

```
flutter packages get
```

Run app

```
flutter run
```

## Learn

- How build layout in flutter
- How read data from Remote Api
- How auto serializing JSON
- How add interactivity with multi widget

repository: acastroy/Github-Trending-App

repo_name: acastroy/Github-Trending-App


text:
# ERC1155 and OpenZepplin

## Status

Approved

## Context

The best way to implement ETH tokens for DSCSA.

## Decision

The ERC1155 token format is more flexible and aims to reduce the cost of the transactions (gas).

## Consequences

More options adds complexity.

branch_name: refs/heads/main


text:
---
layout: v2_fluid/docs_base
category: theming
id: platform-specific-styles
title: Platform Specific Styles
header_title: Platform Specific Styles
header_sub_title: Platform Specific Styles
prev_page_title: Platform Specific Theming
prev_page_link: /docs/v2/theming/platform-specific-styles/
next_page_title: Sass Variables
next_page_link: /docs/v2/theming/sass-variables/
---

Platform Specific Styles

  Improve this doc

Ionic uses modes to customize the look of components to match the platform you are using. For example, when you are viewing the app on an Android device, the `<body>` will have `class="md"` added to it by default:

```html
<body class="md">
```

Here is a chart of the default mode that gets added based on platform:

    Platform
    Mode
    Description

    iOS
    ios
    Applies iOS styling to all components.

    Android
    md
    Applies Material Design styling to all components.

    Windows Phone
    md
    Applies Material Design styling to all components.

    All Other Platforms
    ios
    If you are not on one of the above devices, the app will get iOS styling by default.

You can change the mode that gets assigned in the configuration of your app. Therefore, if you wanted the Material Design `md` mode on iOS, you could do it.

## Overriding the Mode Styles

Each Ionic component has up to three stylesheets used to style it. For example, the tabs component has a core stylesheet that consists of styles shared between all modes, a Material stylesheet which contains the styles for the `md` mode, and an iOS stylesheet for, you guessed it, the `ios` mode. Not all components are styled differently for each mode, so some of them will only have the core stylesheet, or the core stylesheet and one of the modes.

You can use the class that is applied to the body to override specific properties in mode components. For example, if you wanted to override all Material Design (md) mode buttons to have capitalized text:

```scss
.md button {
  text-transform: capitalize;
}
```

The Sass files for these modes also have unique variables that can be used to override the styles. Using the same example above, we could change the `md` button's `border-radius` by changing the value of the `$button-md-border-radius` variable. You can do this in your own custom Sass file or in our main Sass file, before Ionic is imported:

```scss
$button-md-border-radius: 8px;

// Ionic Sass
// ---------------------------------
@import "ionic";
```

## Setting Attributes Dynamically

By setting an attribute dynamically, you can add or remove functionality from a component based on a certain condition. To set an attribute dynamically, use the following syntax:

```html
<ion-list [attr.no-lines]="isMD ? '' : null">
```

This will set the `no-lines` attribute on the list component if `isMD` evaluates to true.

repository: IonicBrazil/ionic-site

repo_name: IonicBrazil/ionic-site


text:
# Nx Setup

## Set up a New Nx Workspace

Run the following command to create a new workspace.

```bash
# pass @latest in case npx cached an older version of create-nx-workspace
npx create-nx-workspace@latest
```

When creating a workspace, you will have to choose a preset, which will preconfigure a few things for you.

```bash
# create an empty workspace set up for building applications
npx create-nx-workspace --preset=apps

# create an empty workspace set up for building packages
npx create-nx-workspace --preset=core

# create an empty workspace set up for building packages with the @nrwl/js plugin installed
npx create-nx-workspace --preset=ts
```

Some presets set up applications, e2e tests, etc.

```bash
npx create-nx-workspace --preset=react
npx create-nx-workspace --preset=react-native
npx create-nx-workspace --preset=angular
```

For more information about possible options see the [create-nx-workspace command](/nx/create-nx-workspace).

## Add Nx to an Existing Project

If you have an existing Lerna or Yarn monorepo, you can gain the benefits of Nx's computation cache and distributed task execution without modifying the file structure by running this command:

```bash
npx add-nx-to-monorepo
```

If you have an existing Create React App project, you can gain the benefits of Nx's computation cache and distributed task execution without modifying the file structure by running this command:

```bash
npx cra-to-nx
```

For more information on adding Nx to an existing repository see the [migration guide](/migration/migration-cra)

## Install Nx CLI

To make the developer experience nicer, you may want to install the Nx CLI globally.

```bash
npm install -g nx
```

## Folder Structure

Nx can be added to any workspace, so there is no fixed folder structure. However, if you use one of the existing presets, you will likely see something like this:

```treeview
myorg/
├── apps/
├── libs/
├── tools/
├── workspace.json
├── nx.json
├── package.json
└── tsconfig.base.json
```

`/apps/` contains the application projects. This is the main entry point for a runnable application. We recommend keeping applications as light-weight as possible, with all the heavy lifting being done by libraries that are imported by each application.

`/libs/` contains the library projects. There are many kinds of libraries, and each library defines its own external API so that boundaries between libraries remain clear.

`/tools/` contains scripts that act on your code base. This could be database scripts, [custom executors](/executors/creating-custom-builders), or [workspace generators](/generators/workspace-generators).

`/workspace.json` lists every project in your workspace. (this file is optional)

`/nx.json` configures the Nx CLI itself. It tells Nx what needs to be cached, how to run tasks etc.

`/tsconfig.base.json` sets up the global TypeScript settings and creates aliases for each library to aid when creating TS/JS imports.

repository: matheo/nx

repo_name: matheo/nx


text:
# Bitcoin SPV in Rust
This is an implementation of Bitcoin's Simplified Payment Verification mode. The SPV mode is suitable for lightweight nodes, such as a mobile phone. An SPV node verifies proof-of-work of a block but does not validate included transactions. It will follow the chain with most work.

An SPV node needs to connect full nodes to work. It does not offer any services to other nodes.

This implementation is taylored to serve a Lightning Network node on a resource and bandwidth limited device. It does not feature a memory pool of transactions, as payments are assumed to use the Lightning layer and otherwise only confirmed transactions are of interest.

## Status
This is work in progess, far from production quality. It aims to serve parallel development of a Lightning Node.

The code currently has a lot of dependencies as I wanted to make progess quickly towards the stuff that is really new. Most dependencies will be removed later.  Networking and Database code is carefully isolated from the logic of the node, so their implementations can be replaced.

I plan to implement BIP157 and BIP158 as soon as they are available in Bitcoin. Until that the node will download full blocks. I do not want to waste time implementing BIP37 that hurts privacy.

## Contributions and Vision
The current plan is to create a small footprint, low bandwidth, stable and secure Lightning Network node combining with the below projects:

* [Rust language bindings for Bitcoin secp256k1 library.](https://github.com/rust-bitcoin/rust-secp256k1)
* [Rust Bitcoin library](https://github.com/rust-bitcoin/rust-bitcoin)
* [Bitcoin's libbitcoinconsenus.a with Rust binding.](https://github.com/rust-bitcoin/rust-bitcoinconsensus)
* [Bitcoin SPV in Rust](https://github.com/rust-bitcoin/bitcoin-spv)
* [Rust-Lightning, not Rusty's Lightning](https://github.com/rust-bitcoin/rust-lightning)
* [Hammersbald]((https://github.com/rust-bitcoin/hammersbald))

Send in your PRs if aligned with above vision.

repository: TheBlueMatt/rust-bitcoin-spv

repo_name: TheBlueMatt/rust-bitcoin-spv


text:
# Application
Generated application with additional custom code for the business logic

# Build
## Local build
Run the following maven command to build the artifact locally:

```
mvn install
```

## Remote build
Travis CI app is used to build the application. The build needs the following environment variables set in order to work:
* TRAVIS_GITHUB_TOKEN: This token is used to update the documentation of the project
* SONAR_TOKEN: This token is used to perform static code analysis within the SonarCloud
* HEROKU_API_KEY: This token is used to deploy the application to the staging and production environment on heroku
* PACKAGECLOUD_TOKEN: This token is used to deploy the application to the maven repository

repository: jstfhv/CI-WeatherApp

repo_name: jstfhv/CI-WeatherApp


text:
<h1> First </h1>

## `git clone https://github.com/lazarok09/react-hooks.git`

### `yarn start`

Runs the app in the development mode.\
Open [http://localhost:3000](http://localhost:3000) to view it in the browser.

### `yarn test`

Launches the test runner in the interactive watch mode.\
See the section about [running tests](https://facebook.github.io/create-react-app/docs/running-tests) for more information.


text:
# **Flow OA**

Flow sub-module extracts and transforms Flow data already ranked by spot-ml and will load into impala tables for presentation the layer.

## **Flow OA Components**

### flow_oa.py
Flow spot-oa main script executes the following steps:

    1. Creates required folder structure if does not exist for output files. This is:

                data: data/flow/<date>/
                ipython Notebooks: ipynb/flow/<date>/

    2. Creates a copy of iPython notebooks out of templates in ipynb_templates folder into output folder.

    3. Reads Flow spot-ml results for a given date and loads only the requested limit.

    4. Add network context to source and destination IPs.

    5. Add geolocation to source and destination IPs.

    6. Stores transformed data in the selected database.

    7. Generates details and chord diagram data. These details include information about aditional connections and some additional information to draw chord diagrams in the UI.

**Dependencies**

- [Python 2.7](https://www.python.org/download/releases/2.7/) should be installed in the node running Flow OA.

The following files and modules are already included but some of them require configuration. See the following sections for more information:
- [components/iana](/spot-oa/oa/components#IANA-iana)
- [components/data](/spot-oa/oa/components#data)
- [components/nc](/spot-oa/oa/components#network-context-nc)
- [components/reputation](/spot-oa/oa/components/reputation)
- flow_config.json

The following files are not included:
- [context/iploc.csv](/spot-oa/oa/context)
- [context/ipranges.csv](/spot-oa/oa/context)

**Prerequisites**

Before running Flow OA users need to configure components for the first time. It is important to mention that configuring these components make them work for other data sources as DNS and Proxy.

- Configure database engine
- Configure GTI services
- Configure IANA service
- Configure Network Context service
- Configure Geolocation service
- Generate ML results for Flow

**Output**

- Flow suspicious connections. _flow\_scores_ table.

Main results for Flow OA. The data stored in this table is limited by the number of rows the user selected when running [oa/start_oa.py](/spot-oa/oa/INSTALL.md#usage).

        Table schema:
        0.   tstart:         string
        1.   srcip:          string
        2.   dstip:          string
        3.   sport:          int
        4.   dport:          int
        5.   proto:          string
        6.   ipkt:           int
        7.   ibyt:           int
        8.   opkt:           int
        9.   obyt:           int
        10.  score:          float
        11.  rank:           int
        12.  srcip_internal:  bit
        13.  destip_internal: bit
        15.  src_geoloc:         string
        16.  dst_geoloc:         string
        17.  src_domain:      string
        18.  dst_domain:      string
        19.  src_rep:      string
        20.  dst_rep:      string

-  Flow details. _flow\_edge_ table.

A query will be executed for each suspicious connection detected, to find the details for each connection occurred during the same specific minute between given source IP and destination IP.

        Table schema:
        0.  tstart:     string
        1.  srcip:      string
        2.  dstip:      string
        3.  sport:      int
        4.  dport:      int
        5.  proto:      string
        6.  flags:      string
        7.  tos:        int
        8.  ibyt:       bigint
        9.  ipkt:       bigint
        10.  pkts:      bigint
        11. input:      int
        12. output:     int
        13. rip:        string
        14. obyt:       bigint
        15. opkt:       bigint
        16. hh:         int
        17. md:         int

- Flow Chord Diagrams.  _flow\_chords_ table.

A query will be executed for each distinct client ip that has connections to 2 or more other suspicious IP. This query will retrieve the sum of input packets and bytes transferred between the client ip and every other suspicious IP it connected to.

        Table schema:
        0. ip_threat:  string
        1. srcip:      string
        2. dstip:      string
        3. ibyt:       bigint
        4. ipkt:       bigint

- Flow Ingest summary. _flow\_ingest\_summary_ table.

This table is populated with the number of connections ingested by minute during that day.

        Table schema:
        0. tdate:      string
        1. total:      bigint

### flow_config.json

Flow spot-oa configuration. Contains columns name and index for input and output files.
This Json file contains 3 main arrays:

    - flow_results_fields: list of column name and index of ML flow_results.csv file. Flow OA uses this mapping to reference columns by name.
    - column_indexes_filter: the list of indices to take out of flow_results_fields for the OA process.
    - flow_score_fields: list of column name and index for flow_scores.csv. After the OA process completes more columns are added.

### ipynb_templates
Templates for iPython notebooks.
After OA process completes, a copy of each iPython notebook is going to be copied to the ipynb/\<pipeline>/\<date> path.
With these iPython notebooks user will be able to perform further analysis and score connections. User can also
experiment adding or modifying the code.
If a new functionality is required for the ipython notebook, the templates need to be modified to include the functionality for posterior executions.
For further reference on how to work with this notebook, you can read:
- [Threat Investigation Notebook](/spot-oa/oa/flow/ipynb_templates/ThreatInvestigation.md)

### Reset scored connections
To reset all scored connections for a day, a specific cell with a preloaded function is included in the Advanced Mode Notebook. The cell is commented to avoid accidental executions, but is properly labeled.

repository: apache/incubator-spot

gha_language: Python

repo_name: apache/incubator-spot


text:
---
layout: service
type: service

name: CHES
title: Common Hosted Email Service
order: 1
description: >-
  Automate the submission of single or bulk email notifications and merge those emails with your beautiful html templates.
  Check your email before sending with a preview feature and check the status of emails after you send them or choose to delete
  emails you sent with a specified time delay from the message queue.

onboard: ['API Access']
onboardDescription: We provide API Access for the Common Hosted Email Service.
urls:
  github: https://github.com/bcgov/common-hosted-email-service
  docs: https://ches-master-9f0fbe-prod.pathfinder.gov.bc.ca/api/v1/docs
  showcase: https://mssc.pathfinder.gov.bc.ca/mssc/

showcaseDescription: >-
  The Messaging Service Showcase  (MSSC) demonstrates how an application can have messaging functionality by calling an API. In this case, it demonstrates how to call two different common messaging APIs: CMSG and CHES.
---
- Send emails with attachments and special business tagging
- Schedule for delayed delivery, with ability to cancel
- Create bulk email merge with your own templates.
- Send plain text or HTML emails
- Track the status of your request


text:
# Change Log

This project adheres to [Semantic Versioning](http://semver.org/).

## 4.2.1

- Fix passing loader options when using `this.getOptions()` from webpack 5.x.x

  ```tsx
  import "clean-css-loader?skipWarn=true!./style.css";
  // {skipWarn: true  }<EMAIL_ADDRESS>  // {skipWarn: 'true'}<EMAIL_ADDRESS>unexpected behavior :(
  ```

  > `loader-utils` has specific behavior for parsing query strings (`true`, `false` and `null` won't be parsed as string but as a primitive value)

## 4.2.0

- Add support [`loader-utils@3.x.x`](https://github.com/webpack/loader-utils/releases/tag/v3.0.0)
- Drop Node.js 10 support

## 4.1.0

- Auto-configure `sourceMap` option, based on [`.devtool`](https://webpack.js.org/configuration/devtool/#devtool)

## 4.0.0

- Migrate to the latest [`clean-css`](https://clean-css.github.io/) version `5.x.x`
- Add Schema validation
- Add new option `disable: boolean`
- Drop support<EMAIL_ADDRESS>- Add Typescript

## 3.0.0

- Drop support node v8
- Update `loader-utils` to the latest version
- Update webpack peer dependencies limit (thanks [@daniele-orlando](https://github.com/daniele-orlando) [#15](https://github.com/retyui/clean-css-loader/issues/15))
- Update dev dependency
- Update webpack e2e tests from `webpack@4` => `webpack@5`

## 2.0.0

- Drop support node v6

## 1.1.0

- Update babel to latest version
- Update dependencies

## 1.0.0

- Init version

repository: retyui/clean-css-loader

repo_name: retyui/clean-css-loader


text:
# Default DDS provider template

## Introduction
Every year, the ROS 2 TSC is mandated to choose a default RMW provider for the next ROS 2 release.
In 2021, that selection will affect Humble Hawksbill, the release scheduled for May 2022.
The default RMW provider must be a Tier 1 provider as specified in [REP-2000](https://www.ros.org/reps/rep-2000.html), and must be open-source.
For Humble Hawksbill, the two RMW providers that meet this criteria are rmw_cyclonedds_cpp and rmw_fastrtps_cpp.

In order to make an informed decision, the TSC needs to be provided with a report that has details about each of the available choices.
The report is comprised of data directly from the RMW providers, plus common language that Open Robotics provides.
This template is the series of questions that each of the RMW providers should answer for that report.
Every question listed below was submitted either by TSC members, or from members of the community based on real world usage.

Remember that the TSC and end-users mostly care about how the DDS implementation works as part of the ROS 2 system, not standalone.
Each response should be measured in context of the entire ROS 2 stack, or should be measured for both the DDS implementation and the ROS 2 stack where there is a significant difference.

It is up to the DDS provider to answer the questions in the way that they feel is best.
That includes choosing the hardware platform, the operating system, the tuning parameters, individual metrics, etc.
Keep in mind that most of the TSC members are users of ROS 2 in robotics applications, so the choices that are made should reflect that.
Choosing only high-end, cloud-connected machines, or only microcontrollers, probably does not match the day-to-day experience of ROS 2 users.
Each choice that is made should be documented, and the rationale for each choice should be explained in the responses to the question.

Each response should be as detailed, accurate, and reproducible as possible.
That means that a detailed description of how any data was collected and analyzed should be included with each answer.
Graphs are very useful and encouraged for each answer where it makes sense.
Where relevant, graphs should show the data from the same test run using rmw_cyclonedds_cpp and rmw_fastrtps_cpp.

Data should be taken using the specific [ros2.repos file](https://github.com/osrf/TSC-RMW-Reports/blob/main/humble/ros2.repos).
When building these packages, they must be built in the default configuration as they will be delivered in ROS 2 Humble.

When the RMW providers are ready to deliver the report (see the Relevant Dates below), they should open a pull request to the [TSC repository](https://github.com/osrf/TSC-RMW-Reports), targeting [README.md](https://github.com/osrf/TSC-RMW-Reports/blob/main/humble/README.md).
The format of the reports should be Markdown, as that is what will be rendered by GitHub into the final report.

## Relevant Dates

* August 31, 2021 - Template is delivered from Open Robotics to ADLINK/Apex.AI and eProsima
* September 20, 2021 - First draft of template responses from ADLINK/Apex.AI and eProsima due - this is to identify any problems early
* October 4, 2021 - Final responses to the template are returned to Open Robotics from ADLINK/Apex.AI and eProsima
* October 12, 2021 - Report is delivered from Open Robotics to the ROS 2 TSC
* October 21, 2021 - Discussion of the report at the monthly TSC meeting
* October 25, 2021 through November 12, 2021 - Voting open to TSC members for default RMW provider
* November 18, 2021 - Announcement of the default RMW provider at monthly TSC meeting
* Early December, 2021 - Based on the outcome of the default RMW provider vote, any required technical changes made to the ROS 2 codebase
* May 23, 2022 - Release of Humble Hawksbill

## Questions
The length of the response to all of the questions combined should be no more than 4000 words, with as many graphs as needed to support that.
If additional space is needed, feel free to provide a link to an external resource with more information.

### Performance
* **_Without configuration, what is the throughput and latency (in addition to any other relevant metrics) when transferring large topics (like ~4K camera images) at medium frequencies (~30Hz)?_**

* Without configuration, how does the implementation scale with the number of topics in the system?

* Without configuration, how does the implementation scale with the number of nodes in the system?

* Please provide benchmarks for inter-host, inter-process (with and without LoanedMessages), and intra-process (with and without LoanedMessages) throughput for both large and small message sizes, on both Linux and Windows.

* For a pub/sub pair in separate processes, what is the average round-trip time, throughput, and CPU/memory utilization? How does this scale with topic frequency and topic size?

### Services
* Several users have reported instances where services never appear, or they never get responses. What do you think the problems might be, and what are you doing to try and address these problems?
    * <https://github.com/ros2/ros2/issues/1074>
    * <https://github.com/ros2/rmw_fastrtps/issues/392>
    * <https://github.com/ros2/rmw_fastrtps/pull/418>
    * <https://github.com/ros2/rmw_cyclonedds/issues/74>
    * <https://github.com/ros2/rmw_cyclonedds/issues/191>

* How do services scale with the number of clients? And/or the amount of request traffic?

### WiFi
We’ve had a lot of reports from users of problems using ROS 2 over WiFi.
What do you think the causes of the problems are, and what are you doing to try to address these problems?

* Some example issues from users:
    * <https://answers.ros.org/question/362065/bad-performance-of-ros2-via-wifi/>
    * <https://discourse.ros.org/t/ros2-default-behavior-wifi/13460/38>
    * <https://discourse.ros.org/t/bad-networks-dragging-down-localhost-communication/20611>

* How well does the implementation work out-of-the-box over WiFi?

* How does the system behave when a robot leaves WiFi range and then reconnects?

* How long does it take to launch a large application like RViz2 over WiFi?

* What is a solution for default DDS discovery on lossy networks?

* How does performance scale with the number of robots present in a WiFi network?

### Features
* What is the roadmap and where is it documented?

* Can the middleware be configured to be memory-static at runtime?

* What support is there for microcontrollers?

* Are there tools available for integrating/bridging with other protocols (MQTT, etc)? What are they, and how do they work?

* How much adherence is there to the RTPS standard?

* How much support for the DDS-Security specification is provided in the DDS implementation?

* Does the package have explicit tooling and support for protocol dissection?

### Quality
* What is the currently declared [REP-2004](https://www.ros.org/reps/rep-2004.html) quality of the package implementing the RTPS/DDS protocols and the RMW?

* How else does the package measure quality? Please list specific procedures or tools that are used.

* Where is the development process documented?

* What kinds of tests are run? Smoke tests, unit tests, integration tests, load tests, coverage? What platforms are each of the tests run on?

* Has the DDS Security implementation been audited by a third-party?

## Free-form

In this section, you can add any additional information that you think is relevant to your RMW implementation.
For instance, if your implementation has unique features, you can explain them here.
These should be things technical in nature, not just marketing.
Please keep your responses limited to 2000 words with a reasonable number of graphs; we’ll truncate anything longer than that during editing of the report.
If you cannot fit all of your data into the limit, feel free to provide a link to an external resource which we’ll include in the report.

repository: joespeed/TSC-RMW-Reports

repo_name: joespeed/TSC-RMW-Reports


text:
# jaeger-client-objc

[![CI Status](http://img.shields.io/travis/pat2man/jaeger-client-objc.svg?style=flat)](https://travis-ci.org/pat2man/jaeger-client-objc)
[![Version](https://img.shields.io/cocoapods/v/jaeger-client-objc.svg?style=flat)](http://cocoapods.org/pods/jaeger-client-objc)
[![License](https://img.shields.io/cocoapods/l/jaeger-client-objc.svg?style=flat)](http://cocoapods.org/pods/jaeger-client-objc)
[![Platform](https://img.shields.io/cocoapods/p/jaeger-client-objc.svg?style=flat)](http://cocoapods.org/pods/jaeger-client-objc)

## Example

To run the example project, clone the repo, and run `pod install` from the Example directory first.

## Requirements

## Installation

jaeger-client-objc is available through [CocoaPods](http://cocoapods.org). To install
it, simply add the following line to your Podfile:

```ruby
pod "Jaeger"
```

## Author

pat2man<EMAIL_ADDRESS>
## License

jaeger-client-objc is available under the MIT license. See the LICENSE file for more info.


text:
---
layout: creature
name: "Wharfling Swarm"
tags: [large, swarm, cr4, tome-of-beasts]
cha: 7 (-2)
wis: 12 (+1)
int: 2 (-4)
con: 8 (-1)
dex: 16 (+3)
str: 10 (+0)
size: Large swarm
alignment: unaligned
challenge: "4 (1100 XP)"
languages: "--"
skills: "Perception +3, Sleight of Hand +5"
senses: "darkvision 60 ft., passive Perception 13"
damage_resistances: "bludgeoning, piercing, slashing"
condition_immunities: "charmed, frightened, paralyzed, petrified, prone, restrained, stunned"
speed: "30 ft., climb 30 ft., swim 20 ft."
hit_points: "63 (14d10 . 14)"
armor_class: "14 (natural armor)"
---

***Swarm.*** The swarm can occupy another creature's space and vice versa, and the swarm can move through any opening large enough for a tiny wharfling. The swarm can't regain hit points or gain temporary hit points.

### Actions

***Bites.*** Melee Weapon Attack: +5 to hit, reach 0 ft., one creature in the swarm's space. Hit: 21 (6d6) piercing damage, or 10 (3d6) piercing damage if the swarm has half of its hit points or fewer.

***Locking Bite.*** When a creature leaves a wharfling swarm's space, 1d3 wharflings remain grappled to them (escape DC 10). Each wharfling inflicts 5 (1d4 + 3) piercing damage at the start of the creature's turns until it escapes from the grapples.

***Pilfer.*** A wharfling swarm makes 1d6 Dexterity (Sleight of Hand) checks each round against every creature in the swarm's space. The DC for each check equals 10 plus the target creature's Dexterity modifier. For each successful check, the wharflings steal some small metallic object from the target, and the theft is unnoticed if the same result equals or exceeds the target's passive Perception.

gha_language: CSS

gha_license_id: NOASSERTION


text:
# github-api-test
Retrieve user info from github API using React and Express

## Getting Started

These instructions will get you a copy of the project up and running on your local machine for development and testing purposes.

### Installing dependencies

install dependencies by entering client and server directories and using the command below:

```
npm i
```

And run the client and dev server using:

```
npm start
```
Now you can enter a github username and the user's name, followers, repos' info and more will be presented to you!

## License

This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details\
![licence](https://img.shields.io/badge/license-MIT-green)

repository: miladgy/github-fetch-test

repo_name: miladgy/github-fetch-test


text:
Vue Testing Library

Lightweight adapter allowing DOM Testing Library to be used to test Vue.js components. Built on top of <a<EMAIL_ADDRESS>

[**Read The Docs**](https://testing-library.com/vue) |
[Edit the docs](https://github.com/testing-library/testing-library-docs)

[![Build Status](https://travis-ci.org/testing-library/vue-testing-library.svg?branch=master)](https://travis-ci.org/testing-library/vue-testing-library)
[![Coverage Status](https://coveralls.io/repos/github/testing-library/vue-testing-library/badge.svg?branch=master)](https://coveralls.io/github/testing-library/vue-testing-library?branch=master)
[![GitHub version](https://badge.fury.io/gh/testing-library%2Fvue-testing-library.svg)](https://badge.fury.io/gh/testing-library%2Fvue-testing-library)

[![npm version](https://badge.fury.io/js/vue-testing-library.svg)](https://badge.fury.io/js/vue-testing-library)
[![license](https://img.shields.io/github/license/testing-library/vue-testing-library.svg)](https://img.shields.io/github/license/testing-library/vue-testing-library)

Table of Contents

- [Installation](#installation)
- [Examples](#examples)
- [Docs](#docs)
- [License](#license)
- [Contributors](#contributors)

## Installation

This module is distributed via npm which is bundled with node and
should be installed as one of your project's `devDependencies`:

```
npm install --save-dev @testing-library/vue
```

You may also be interested in installing `jest-dom` so you can use
[the custom Jest matchers](https://github.com/gnapse/jest-dom#readme).

## Examples

```html
<!-- TestComponent.vue -->
<template>
  <div>
    <p>Times clicked: {{ count }}</p>
    <button @click="increment">increment</button>
  </div>
</template>

<script>
export default {
  data: () => ({
    count: 0
  }),
  methods: {
    increment () {
      this.count++
    }
  }
}
</script>
```

```js
// TestComponent.spec.js
import { render, fireEvent, cleanup } from '@testing-library/vue'
import TestComponent from './TestComponent.vue'

// automatically unmount and cleanup DOM after the test is finished.
afterEach(cleanup)

it('increments value on click', async () => {
  // The render method returns a collection of utilities to query your component.
  const { getByText } = render(TestComponent)

  // getByText returns the first matching node for the provided text, and
  // throws an error if no elements match or if more than one match is found.
  getByText('Times clicked: 0')

  const button = getByText('increment')

  // Dispatch a native click event to our button element.
  await fireEvent.click(button)
  await fireEvent.click(button)

  getByText('Times clicked: 2')
})
```

You'll find examples of testing with different libraries in
[the test directory](https://github.com/testing-library/vue-testing-library/tree/master/tests/__tests__).

Some included are:

* [`vuex`](https://github.com/testing-library/vue-testing-library/tree/master/tests/__tests__/vuex.js)
* [`vue-router`](https://github.com/testing-library/vue-testing-library/tree/master/tests/__tests__/vue-router.js)
* [`vee-validate`](https://github.com/testing-library/vue-testing-library/tree/master/tests/__tests__/validate-plugin.js)

Feel free to contribute with more!

## Docs

[**Read The Docs**](https://testing-library.com/vue) |
[Edit the docs](https://github.com/testing-library/testing-library-docs)

## License

MIT

## Contributors

[![dfcook](https://avatars0.githubusercontent.com/u/10348212?v=3&s=200)](https://github.com/dfcook)
[![afontcu](https://avatars3.githubusercontent.com/u/9197791?s=200&v=3)](https://github.com/afontcu)
[![eunjae-lee](https://avatars0.githubusercontent.com/u/499898?v=3&s=200)](https://github.com/eunjae-lee)
[![tim-maguire](https://avatars0.githubusercontent.com/u/29452317?v=3&s=200)](https://github.com/tim-maguire)
[![samdelacruz](https://avatars0.githubusercontent.com/u/2040007?v=3&s=200)](https://github.com/samdelacruz)
[![ankitsinghaniyaz](https://avatars0.githubusercontent.com/u/11331989?v=3&s=200)](https://github.com/ankitsinghaniyaz)
[![lindgr3n](https://avatars0.githubusercontent.com/u/24882614?v=3&s=200)](https://github.com/lindgr3n)
[![kentcdodds](https://avatars0.githubusercontent.com/u/1500684?v=3&s=200)](https://github.com/kentcdodds)

repository: makeupsomething/vue-testing-library

repo_name: makeupsomething/vue-testing-library


text:
# MLiy User Guide
## MLiy Web Application
The MLiy Web Application allows you to launch and manage MLiy instances and is accessible via the published URL. You will need to logon with your credentials.
### Pre-requisites
- A user account in MLiy Web Application or authorized to login via LDAP/Active Directory Group Membership
- SSH key for the MLiy instance or Membership in a LDAP/Active Directory Group that is authorized to login to the MLiy instance
- Assigned to a preconfigured group in MLiy Web Application
- Firefox or Chrome
### My Dashboard
After you logon to the MLiy Web Application, you will land on your dashboard. Your dashboard lists all the instances you have launched earlier (but not terminated), their instance types, their operational status, their software configuration label, and their uptime if running. Each instances will have an associated web link on the far left and a manage link on the far right. Clicking on the web link will take you to the home page of that instance. Clicking on the manage link will display information about the instance and will allow you to stop, start, reboot or terminate the instance depending on its current state.
### Team Dashboard
Team dashboard (link accessible via the left navigation) lists all instances belonging to members of all the groups you belong to. The columns are the same as in your dashboard except that there is no associated web and manage links. Clicking on the instance ID will display some information about the instance such as owner, software configuration, instance type, state, IP address, stop and start time, last refreshed from AWS, and EBS volume ID.
### Launch New Instance
Click on “Launch” in the left navigation pane to launch a new MLiy instance. You will be asked to select a group if you belong to multiple groups. You will not see the “Launch Group select” screen if you belong to just one group.

Select the Software Configuration to launch. Your group may be assigned to more than one Software Configurations.

Select the EC2 instance type.

Click on the “Launch Instance” button. You will see the launch progress bar indicating launch status. Depending on the image, instance launch time will vary.

Once launch is complete, you will automatically be redirected to your dash board.

In your dashboard, you will see the provisioning status of each of the launched instances.

### Manage an Instance
- To manage your instance, click on the “Manage Link” associated with that instance.
- If the instance is stopped, you will see the buttons to start or terminate that instance.
- If the instance is running, you will see the buttons to stop, reboot or terminate instance.

### MLiy EC2 Image
A sample EC2 image for Data Science is included with MLiy. Your administrators may have other images published. User guide for the sample MLiy EC2 image is included in a separate documentation: [MLiy Image Guide].

### Launch New Cluster

#### Requirements
- The user must be in a Group that allows EMR cluster creation
- EMR Cluster Software Configurations must exist in the databse

Click on “Launch” in the left navigation pane to launch a new MLiy cluster. You will be asked to select a group if you belong to multiple groups. You will not see the “Launch Group select” screen if you belong to just one group.

Select the Software Configuration to launch. Your group may be assigned more than one Software Configuration.

Select the options for your cluster.

|Field|Description|
|---|---|
|Instance Type    | Type of instances you want for your cluster. |
|Purpose          | Purpose of the cluster. This will also become a tag in the Cloudformation stack. |
|Core Nodes       | Number of core nodes to provision for the EMR cluster. |
|Market Type      | Choose between Spot and On-Demand pricing. Choosing On-Demand will disable the Spot Bid Price field. |
|Bid Price        | If On Demand is unchecked, select the bid price for the SPOT instance.|
|Auto Termination | The Hours : Minutes that the cluster needs to be idle before terminating itself. |

Click on the "Launch Cluster" button.

In your dashboard you will see the provisioning status of each of the launched clusters.

### Connecting to a Cluster
Once the cluster starts, the status will eventually change to the WAITING state, at which point the cluster can be accessed. Select the "Manage Link" for more information on the cluster.

Cluster connection methods will vary depending on the applications installed and the cluster's purpose. The example Spark cluster provides a landing web page on the master node's IP address and subsequently Jupyterhub, Spark, and other applications. A Hive cluster on the other hand may connect through a JDBC link.

Custom links (e.g. "jdbc:hive//j-00000000.my_url.org:10000") can be viewed in the "Manage Link" associated with the cluster in the user dashboard in the row "Connection". This can be specified in the Software Config. See [Administrator Guide] on how to set the custom parameter.

### Manage a Cluster
- To manage your cluster, click on the “Manage Link” associated with that cluster in the user dashboard.
- The "Terminate" button on the bottom will terminate the cluster and delete the Cloudformation stack.
- If a cluster fails to go up, or encounters a terminal state, and if it has been in this state for an hour, MLiy will automatically remove the cluster and the Cloudformation stack.

[MLiy Image Guide]:./MLiyImageGuide.md
[Administrator Guide]:./AdministratorGuide.md

repository: FINRAOS/MLiy

gha_language: Shell

repo_name: FINRAOS/MLiy


text:
# News and Notifications by Version

This file lists noteworthy changes which may affect users of this project.  More
detailed information is available in the rest of the documentation.

<b>NOTE:</b> Date stamps in the following entries are in YYYY/MM/DD format.

## v0.3.1 (2020/02/09)

* Removed the rubyforge reference from the gemspec (Jordan Pickwell)

## v0.3.0 (2009/04/29)

* Fixed the rewind method to work with write-only streams
* Fixed the read, gets, and readline methods to return partial data if they have
  such data but receive low level errors before reaching a stopping point
* Renamed all private methods so that it is highly unlikely that they will be
  accidentally overridden
* Eliminated warnings caused by referencing uninitialized instance variables
* Improved the documentation for the read, gets, and readline methods

## v0.2.0 (2009/03/11)

* Added mspec tests borrowed from the rubyspec project
* Fixed many, many defects related to IO compatibility (Mostly obscure corner
  cases)

## v0.1.0 (2008/07/03)

* Initial release
* All read, write, and seek functions implemented as defined in Ruby 1.8.6
* Most other IO methods also provided as no-ops and similar

repository: dasileker/private-events

branch_name: refs/heads/development

repo_name: dasileker/private-events


text:
---
layout: labitem
title: Part 3 - RRC pulse shaping

permalink: /ece450/lab2/rrc-shaping
course: ece450
prev: /ece450/lab2/lpf-shaping
next: /ece450/lab2/calculating-ber
---

## Objectives

You will implement a communications system using a Root Raised Cosine (RRC) filter for pulse shaping.

---

## Part 3 deliverables

For this section, the deliverables are:

- the answers to two deliverable questions,
- a dataset for later use in this lab.

---

## RRC pulse shaping flowgraph

Construct the following GRC flowgraph. It is very similar to the previous pulse shaping flowgraphs. You can "File>Save As" in GRC in order to not begin from scratch again.

  ![rrc-blank-flowgraph.png](figures/rrc-blank-flowgraph.png)

  __*Blank RRC pulse shaping flowgraph*__

### Variables

- Replace the `sigma` variable with an `eb_n0_db` variable and set the value to 0.
- Leave the `sig_pwr` variable blank for now.

{% include alert.html title="Note" content="GR version <IP_ADDRESS> on windows might cause problems if you don't cast the value to a `float()`." %}

### Import

The argument is `import math`. This will load the [python math library](https://docs.python.org/3/library/math.html). To call the library functions you would precede them with `math`. For example, to take the square root of the number 5 you would write `math.sqrt(5)` wherever you wanted the result.

### Root Raised Cosine Filter (Transmitting)

The tranmitter chain is now pulse shaping with a *Root Raised Cosine Filter* block. Some parameters for the filter are

- the filter is of type "Float->Float (Interpolating)",
- the filter roll-off factor ($$\alpha$$) indirectly specifies the bandwidth of the filter. Set $$\alpha=0.35$$.
- An ideal RRC filter has an infinite number of taps but in practice must be windowed. Set the number of taps to the sampling rate.
- The symbol rate is the same as it was in the last lab section,
- The interpolation factor is the same as for the previous pulse-shaping method (and for all pulse shaping methods it is the number of samples per symbol when coming from a bit stream to a waveform).
- The gain can be found in the same way as with the LPF pulse shaping. Measure the amplitude and set the gain such that the peak of the shaped pulses are at about 1.

### Root Raised Cosine Filter (Receiving)

The receiver chain is now using a matching *Root Raised Cosine Filter* to obtain a final pulse shape that is a raised cosine (review [the theory section]({{ site.baseurl }}{% link _ece450/lab2/theory.md %}) for more on this).

- The filter is of type "Float->Float (Decimating)"
- Set the number of taps to the sampling rate.
- Set the symbol rate and decimation rates appropriately.
- Do not change the gain, by observing the output of the filter you will see that the input symbols (scaled to 1 above) are all either 1 or -1.

{% include alert.html title="Note" content="Since this is a **matched filter** it is the dual to the transmitter RRC filter. Its parameters should reflect this." %}

{% include alert.html title="Deliverable question 2" class="info" content="Consider the time domain shape (impulse response) of the root raised cosine filter. In an ideal system, RRC filters have zero-ISI (inter-symbol interference). Why is this? It may help your understanding to draw multiple pulses `[1, 1, 1]` next to each other." %}

### Skip Head

The offset between sequences can be found as before. It is 1000 samples with the above listed filter parameters (which means a 500 sample delay for each component of the matched filter).

### Validate the filter

Ensure that the offset and matched filter are working by setting the *Amplitude* of the *Noise Source* block to 0 and checking that the BER is 0.

### Finding the signal power

In order to control the simulation, we need to set the `eb_n0_db` variable and have that control the noise power ($$\sigma$$) in the *Noise Source* block. This can be done using the equation you derived in the prelab. In translating the equation into a line of python (so that it can be used in GNU Radio), see that $$f_{SYM}$$ is `symbol_rate` and $$f_s$$ is `samp_rate`.

In this equation, $$a_i^2$$ is the signal power. This is the only parameter still unknown. Build the following three blocks to measure the signal power and attach the output of the transmitting RRC to both inputs of the multiply block.

  ![power-measurement.png](figures/power-measurement.png)

  __*Flow diagram to measure average power of a data stream.*__

The *Length* of the *Moving Average* block is 100000 and the *Scale* is the inverse (ensure that the inverse is a float and not an integer.)

{% include alert.html title="Note" content="Ensure that the *Scale* parameter is a float and not an integer. GR versions < 3.8 are build on Python 2 and so 1/100000 will result in the int 0. GR versions 3.8+ are built on Python 3 and so the same argument will yield the float 0.00001. In GR versions < 3.8 this can be solved by casting the entire argument as a float by wrapping it with a `float()`." %}

Run the flowgraph and record this power value. Take a second and consider whether the value you have measured is reasonable. The peaks of the RRC output are at about 1 after the gain adjustment above. Save the measured value in the `sig_pwr` variable block.

Now all of the variables in the above derivation for $$\sigma$$ have been found. It is now possible to control the $$\frac{E_b}{N_0} \text{ (dB)}$$ of the system by holding the signal power constant and varying the noise power. Enter the expression for $$\sigma$$ in the *Amplitude* parameter of the *Noise Source* block. It should be a function of `samp_rate`, `symbol_rate`, `sig_pwr`, and `eb_n0_db`.

## Running the experiment

1. Run the flowgraph. Record the BER at $$\frac{E_b}{N_0}$$ values of 0, 2, 4, 6, 8 dB.
   - Plotting the time sink values also eats computational power. You may disable the *QT GUI Time Sink* blocks and any other unneeded QT GUI blocks.
   - __* Ensure that when you change the `eb_n0_db` variable value that the Amplitude of the Noise Source also changes. If sigma is not changing something is wrong (if you're on windows, you might be able to wrap the `eb_n0_db` variable in a `float()` cast. *__
2. Offset the delay (in the *Skip Head* block) by a single sample. Check the BER with no added noise.
3. When discussing an Eb/N0 value, it refers to the *received* energy per bit/noise power ratio. The $$\sigma$$ formula above is true for a matched filter as it relies on the *input* signal power and is true for WGN. What if this simulation was not a MF and not WGN? The standard method of calculating Eb/N0 would be to measure the output signal and noise powers as done in the [previous section]({{ site.baseurl }}{% link _ece450/lab2/lpf-shaping.md %}) of the lab. Conduct the appropriate measurements to find the Eb/N0 value independent of input signal or noise powers.
   - Add the __*Multiply->Moving Average->QT GUI Number Sink*__ power measuring chain to the output of the receiving RRC filter. Record a power measurement there for:
     - Signal power (set noise power to 0).
     - Noise powers required for Eb/N0 of 0, 2, 4, 6, 8 dB (to do this, set the *Gain* in the Transmitting RRC to 0)

{% include alert.html title="Deliverable question 3" class="info" content="Consider the relative impact of noise versus a timing offset on the system. Does the RRC filter fare any better than the LPF did with an offset of 1 sample?" %}

From this section you should have recorded 5 BER values, 5 output noise power values and 1 output signal power value.

Review the [section deliverables](#part-3-deliverables) beforing moving on.

repository: mistic-lab/ece-communications-labs

repo_name: mistic-lab/ece-communications-labs


text:
# Changelog
All notable changes to this project will be documented in this file.

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)

## [Ideas/Upcoming]
* Outlookbar (NavigationBar, Accordion)
* Pageinator (PagingControl)

## [Unreleased]

## [1.8.2] - 2021-08-06
### Fixed
* StackPanel, UniformPanel and ItemsPanel now take care about items be set on collapsed
* The UniformPanel or Uniform ItemsPanel does not crash anymore if the height or width of the children became negative

## [1.8.0] - 2021-08-05
### Added
* StackPanel, a control which behaves like the original stack panel but with the additional property for a spacing between the children
* UniformPanel, A UniformGrid with only one row or one column, depending on the orientation, which adds a spacing between the items
* ItemsPanel, a combined control between StackPanel and UniformPanel

## [1.6.0] - 2021-07-25
### Added
* ArcPanel which arranges child elements in a configurable arc form.
* EllipsePanel which arranges child elements in a ellipse form.
* UniformWrapPanel which enhances the WrapPanel by the feature that all items will have the same size.
* Resizer which brings the possibility to resize every UI control manually by hold and drag the corners or sides.
* HeaderItemsControl to allign items with a header and content vertically or horizontally.
* DynamicTabControl which is a tab control with add and remove buttons.

## [1.0.0] - 2021-06-13
### Added
* TitledItemsControl (Brings a layout for title - content in a list alligned. Like a input form)


text:
# elasticsearch-chikkar

[![Build Status](https://github.com/WorksApplications/elasticsearch-chikkar/actions/workflows/gradle.yml/badge.svg)](https://github.com/WorksApplications/elasticsearch-chikkar/actions/workflows/gradle.yml)
[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=com.worksap.nlp%3Aanalysis-chikkar&metric=alert_status)](https://sonarcloud.io/dashboard?id=com.worksap.nlp%3Aanalysis-chikkar)

This project will be merged into [elasticsearch-sudachi](https://github.com/WorksApplications/elasticsearch-sudachi).

A synonym token filter plugin for Elasticsearch

# usage example:

suppose we use `Sudachi` for tokenizer.

## use synonym dictionaries in text format

* Pass `chikkar_synonym` for the type of chikkar plugin.
* Set `system_dict` to specifiy system synonym dictionary path. The path should be relative path to the ES config folder, as ES can only access files under config folder.
* Set `user_dict_list` with a list of user synonym dictionary paths. The paths should be relative path to the ES config folder, as ES can only access files under config folder.

```
{
  "settings": {
    "index": {
      "analysis": {
        "tokenizer": {
          "sudachi_tokenizer": {
            "type": "sudachi_tokenizer",
            "split_mode" : "C",
            "discard_punctuation": true,
            "resources_path": "/usr/share/elasticsearch/config"
          }
        },
        "filter" : {
            "chikkar_filter" : {
                "type" : "chikkar_synonym",
                "system_dict": "hr/hr_synonym_core.txt",
                "user_dict_list": ["hr/user_dict_1.txt", "hr/user_dict_2.txt", "hr/user_dict_3.txt"]
            }
        },
        "analyzer": {
          "sudachi_analyzer_no_synonym": {
            "filter": ["sudachi_normalizedform"],
            "tokenizer": "sudachi_tokenizer",
            "type": "custom"
          },
          "sudachi_analyzer_chikkar_synonym": {
            "filter": [
              "sudachi_normalizedform",
              "chikkar_filter"
            ],
            "tokenizer": "sudachi_tokenizer",
            "type": "custom"
          }
        }
      }
    }
  },
  "mappings": {
    "properties": {
        "content": {
            "type": "text",
            "analyzer": "sudachi_analyzer_no_synonym",
            "search_analyzer": "sudachi_analyzer_chikkar_synonym",
            "term_vector": "with_positions_offsets"
        }
    }
  }
}
```

repository: WorksApplications/elasticsearch-chikkar

branch_name: refs/heads/develop

gha_language: Java

repo_name: WorksApplications/elasticsearch-chikkar


text:
<!-- Do not edit this file. It is automatically generated by API Documenter. -->

[Home](./index.md) > [@nextgis/ngw-connector](./ngw-connector.md) > [BookmarkProperties](./ngw-connector.bookmarkproperties.md) > [place](./ngw-connector.bookmarkproperties.place.md)

## BookmarkProperties.place property

<b>Signature:</b>

```typescript
place: string;
```


text:
# QQ Group Chatting Robot
![](https://img.shields.io/badge/language-Kotlin-blueviolet.svg)
![](https://img.shields.io/badge/license-MIT-blue.svg)

## Introduction
This is a QQ robot back-end for group chatting.
The robot will try matching the keywords.
Once the keyword is hit, the robot will reply the preset paragraph.

**This readme file is still under construction.**

## Features
1. On-the-fly keyword modifying.
1. Operators supported. (They can access the server settings via private (or group) conversations with the robot.)
1. Blacklist supported. Users in blacklist will be ignored.
1. A simple command prompt.
1. Keywords loading and saving.
1. Keywords isolation among conversations.
1. Cool down time limitation.

## Get Started

**NOTE:** Our robot is referred as "back-end" in the following instructions.

**NOTE:** If the instruction make you confused, don't be worried. The README file needs supplement, and I will try to make it more clear in the following days.
1. Download CoolQ Air ([Official website](https://cqp.cc/)), and install the plugin [CoolQ HTTP API](https://cqp.cc/t/30748).
(Pro is better but not necessary.)
1. Deploy the plugin as HTTP server, and set `post_url` in configuration file as our Kotlin back-end's address. (default port is defined as `1080`, which lies in `/src/main/data/Global.kt`,the var `localPort`) [Official docs here](https://cqhttp.cc/docs/4.10/#/).
1. Modify `remoteAddress` (defined in `/src/main/data/Global.kt`) to the CoolQ HTTP API listening address. (e.g. for users whose CoolQ runs on localhost, at the port of 5700, the remote address may be <IP_ADDRESS>:5700)
1. Now launch our back-end, CoolQ Air and enable CoolQ HTTP API plugin.
1. As a test. you can send a message `syn` to your bot. If your configuration is correct, you'll receive `ack` from the robot.


text:
Customization
=============

This document describes how to customize this authorization server
implementation.

Overview
--------

This authorization server implementation uses [Authlete][1] as its backend.
What this means are (1) that the core part of the implementation of [OAuth
2.0][2] and [OpenID Connect][3] is not in the source tree of java-oauth-server
but in the Authlete server on cloud, and (2) that authorization data such as
access tokens, settings of the authorization server itself and settings of
client applications are not stored in any local database but in the database
on cloud. Therefore, to put it very simply, this implementation is just an
intermediary between client applications and Authlete server as illustrated
below.

```
+--------+          +-------------------+          +----------+
|        |          |                   |          |          |
| Client | <------> | java-oauth-server | <------> | Authlete |
|        |          |                   |          |          |
+--------+          +-------------------+          +----------+
```

However, because Authlete focuses on **authorization** and does NOT do
anything about end-user **authentication**, functions related to
authentication are implemented in the source tree of java-oauth-server.

Therefore, at least, you must customize parts related to end-user authentication.
On the other hand, customization of other parts such as UI design of the
authorization page is optional.

Overall Structure
-----------------

Authlete provides [Web APIs][4] that can be used to write an authorization
server. [authlete-java-common][5] is a library which directly communicates
with the Web APIs, and [authlete-java-jaxrs][6] is a library which provides
utility classes wrapping the [authlete-java-common API][7] to make it much
easier for developers to implement an authorization server than using
authlete-java-common API directly. java-oauth-server is written using
[authlete-java-jaxrs API][8] exposed by the utility classes.

As its name implies, authlete-java-jaxrs library depends on JAX-RS 2.0 API.
JAX-RS means _The Java API for RESTful Web Services_. JAX-RS 2.0 API has
been standardized by [JSR 339][9] and it is included in Java EE 7.

The figure below illustrates the relationship among the components mentioned
so far.

```
+-------------------------------+
|          java-oauth-server    |
+----+--------------------------+
|    |     authlete-java-jaxrs  |
|    +---+----------------------+          +----------+
| JAX-RS | authlete-java-common | <------> | Authlete |
+--------+----------------------+          +----------+
```

Authorization Endpoint
----------------------

The implementation of the authorization endpoint is in
[AuthorizationEndpoint.java][14]. The code is incredibly short
although it supports OpenID Connect in addition to OAuth 2.0. There is little
need to change this file.

The implementation uses [AuthorizationRequestHandler][15] class
and delegates the task to handle an authorization request to `handle()` method
of the class. Details about the class is written in the README file of
[authlete-java-jaxrs][6] library. What is important here is that the
constructor of the class requires an implementation of
[AuthorizationRequestHandlerSpi][16] interface and that the
implementation must be provided by you. In other words, the methods in
`AuthorizationRequestHandlerSpi` interface are customization points.

The interface has the methods listed below. See the [JavaDoc][8] of
authlete-java-jaxrs API for details about the requirements of these methods.

  1. `boolean isUserAuthenticated()`
  2. `long getUserAuthenticatedAt()`
  3. `String getUserSubject()`
  4. `String getAcr()`
  5. `Response generateAuthorizationPage(AuthorizationResponse)`

The most important method among the above is
[generateAuthorizationPage()][17]. The method is called to
generate an authorization page. In contrast, the other methods are not so
important because they are called only when an authorization request comes
with a special request parameter `prompt=none`. If you have no mind to
support `prompt=none`, you can leave your implementations of the methods
empty. Details about `prompt=none` is written in
"[<IP_ADDRESS>. Authorization Request][10]" of [OpenID Connect Core 1.0][11].

The implementation of `AuthorizationRequestHandlerSpi` interface in
java-oauth-server is written in
[AuthorizationRequestHandlerSpiImpl.java][18]. The implementation
class in the file, `AuthorizationRequestHandlerSpiImpl`, extends
[AuthorizationRequestHandlerSpiAdapter][19] class which is an
empty implementation of `AuthorizationRequestHandlerSpi` interface, and
overrides `generateAuthorizationPage()` method only. The code snippet below
shows the rough structure of the implementation.

```java
class AuthorizationRequestHandlerSpiImpl extends AuthorizationRequestHandlerSpiAdapter
{
    ......

    @Override
    public Response generateAuthorizationPage(AuthorizationResponse info)
    {
        ......
    }
}
```

Authorization Page
------------------

As mentioned, `generateAuthorizationPage()` in `AuthorizationRequestHandlerSpi`
interface is a method to generate an authorization page. The current
implementation of the method in java-oauth-server retrieves data from the
argument (an intance of [AuthorizationResponse][20] class which
represents a response from Authlete's `/api/auth/authorization` API) and
embeds them into an HTML template, [authorization.jsp][21].
To achieve this, the implementation uses `Viewable` class. The class is
included in [Jersey][12] (the reference implementation of JAX-RS), but it
is not a part of JAX-RS 2.0 API.

If you want to customize the authorization page, change the implementation
of `generateAuthorizationPage()` method and/or the template of the
authorization page (`authorization.jsp`). See the [JavaDoc][7] of
authlete-java-common library for details about `AuthorizationResponse`
class.

#### Internationalization

For the internationalization of the authorization page, you may take
`ui_locales` parameter into consideration which may be contained in an
authorization request. It is a new request parameter defined in [OpenID
Connect Core 1.0][11]. The following is the description about the parameter
excerpted from the specification.

> OPTIONAL. End-User's preferred languages and scripts for the user interface,
> represented as a space-separated list of BCP47 [RFC5646] language tag values,
> ordered by preference. For instance, the value "fr-CA fr en" represents a
> preference for French as spoken in Canada, then French (without a region
> designation), followed by English (without a region designation). An error
> SHOULD NOT result if some or all of the requested locales are not supported
> by the OpenID Provider.

You can get the value of `ui_locales` request paremeter as a `String` array
by calling `getUiLocales()` method of `AuthorizationResponse` instance. Note
that, however, you have to explicitly specify which UI locales to support
using the management console ([Service Owner Console][13]) because
`getUiLocales()` method returns only supported UI locales. In other words,
it is ensured that the array returned by `getUiLocales()` never contains
unsupported UI locales whatever `ui_locales` request parameter contains.

It is up to you whether to honor `ui_locales` parameter or not. Of course,
you may use any means you like to internationalize the authorization page.

#### Display type

An authorization request may contain `display` request parameter to specify
how to display the authorization page. It is a new request parameter defined
in [OpenID Connect Core 1.0][11]. The predefined values of the request
parameter are as follows. The descriptions in the table are excerpts from
the specification.

| Value | Description |
|:------|:------------|
| page  | The Authorization Server SHOULD display the authentication and consent UI consistent with a full User Agent page view. If the display parameter is not specified, this is the default display mode. |
| popup | The Authorization Server SHOULD display the authentication and consent UI consistent with a popup User Agent window. The popup User Agent window should be of an appropriate size for a login-focused dialog and should not obscure the entire window that it is popping up over. |
| touch | The Authorization Server SHOULD display the authentication and consent UI consistent with a device that leverages a touch interface. |
| wap   | The Authorization Server SHOULD display the authentication and consent UI consistent with a "feature phone" type display. |

You can get the value of `display` request parameter as an instance of
[Display][22] enum by calling `getDisplay()` method of
`AuthorizationResponse` instance. By default, all the display types are
checked as supported in the management console ([Service Owner Console][13]),
but you can uncheck them to declare some values are not supported. If an
unsupported value is specified as the value of `display` request parameter,
it will result in returning an `invalid_request` error to the client
application that made the authorization request.

TBW

Authorization Decision Endpoint
-------------------------------

In an authorization page, an end-user decides either to grant permissions to
the client application which made the authorization request or to deny the
authorization request. An authorization server must be able to receive the
decision and return a proper response to the client application according to
the decision.

The current implementation of java-oauth-server receives the end-user's
decision at `/api/authorization/decision`. In this document, we call the
endpoint _authorization decision endpoint_. In java-oauth-server, the
implementation of the authorization decision endpoint is in
[AuthorizationDecisionEndpoint.java][29].

The implementation uses [AuthorizationDecisionHandler][30] class
and delegates the task to handle an end-user's decision to `handle()` method
of the class. Details about the class is written in the README file of
[authlete-java-jaxrs][6] library. What is important here is that the
constructor of the class requires an implementation of
[AuthorizationDecisionHandlerSpi][31] interface and that the
implementation must be provided by you. In other words, the methods in
`AuthorizationDecisionHandlerSpi` interface are customization points.

The interface has the methods listed below. See the [JavaDoc][8] of
authlete-java-jaxrs API for details about the requirements of these methods.

  1. `boolean isClientAuthorized()`
  2. `long getUserAuthenticatedAt()`
  3. `String getUserSubject()`
  4. `String getAcr()`
  5. `getUserClaim(String claimName, String languageTag)`

The implementation of `AuthorizationDecisionHandlerSpi` interface in
java-oauth-server is written in
[AuthorizationDecisionHandlerSpiImpl.java][32]. The implementation
class in the file, `AuthorizationDecisionHandlerSpiImpl`, extends
[AuthorizationDecisionHandlerSpiAdapter][33] class which is an
empty implementation of `AuthorizationDecisionHandlerSpi` interface, and
overrides all the methods except `getAcr()`. The code snippet below shows
the rough structure of the implementation.

```java
class AuthorizationDecisionHandlerSpiImpl extends AuthorizationDecisionHandlerSpiAdapter
{
    ......

    @Override
    public boolean isClientAuthorized()
    {
        ......
    }

    @Override
    public long getUserAuthenticatedAt()
    {
        ......
    }

    @Override
    public String getUserSubject()
    {
        ......
    }

    @Override
    public Object getUserClaim(String claimName, String languageTag)
    {
        ......
    }
}
```

#### End-User Authentication

Authlete does not care about how to authenticate an end-user at all.
Instead, Authlete requires the subject of the authenticated end-user.

_Subject_ is a technical term in the area related to identity and it means
a unique identifier. In a typical case, subjects of end-users are values of
the primary key column or another unique column in a user database.

When an end-user grants permissions to a client application, you have
to let Authlete know the subject of the end-user. In the context of
`AuthorizationDecisionHandlerSpi` interface, this can be described as
follows: _"if `isClientAuthorized()` returns `true`, then `getUserSubject()`
must return the subject of the end-user."_

For end-user authentication, java-oauth-server has `UserDao` class and
`UserEntity` class. These two classes compose a dummy user database.
Of course, you have to replace them with your own implementation to
refer to your actual user database.

Token Endpoint
--------------

The implementation of the token endpoint is in [TokenEndpoint.java][23].
The code is incredibly short and there is little need to change the content of
the file.

The implementation uses [TokenRequestHandler][24] class and delegates
the task to handle a token request to `handle()` method of the class. Details about
the class is written in the README file of [authlete-java-jaxrs][6] library. What
is important here is that the constructor of the class requires an implementation
of [TokenRequestHandlerSpi][25] interface and that the implementation
must be provided by you. In other words, the methods in `TokenRequestHandlerSpi`
interface are customization points.

The current definition of the interface has only one method named `authenticateUser`.
This method is used to authenticate an end-user. However, the method is called
only when the grant type of a token request is [Resource Owner Password
Credentials][26]. Therefore, if you have no mind to support the grant type,
you can leave your implementation of the method empty.

The implementation of `TokenRequestHandlerSpi` interface in java-oauth-server
is written in [TokenRequestHandlerSpiImpl.java][27]. The implmentation
class in the file, `TokenRequestHandlerSpiImpl`, extends
[TokenRequestHandlerSpiAdapter][28] class which is an empty
implementation of `TokenRequestHandlerSpi` interface, and overrides
`authenticateUser()` method. The code snippet below shows the rough structure of
the implementation.

```java
class TokenRequestHandlerSpiImpl extends TokenRequestHandlerSpiAdapter
{
    ......

    @Override
    public String authenticateUser(String username, String password)
    {
        ......
    }
}
```

Introspection Endpoint
----------------------

The implementation of the introspection endpoint is in
[IntrospectionEndpoint.java][34].

[RFC 7662][35] (OAuth 2.0 Token Introspection) requires that the endpoint
be protected in some way or other. The implementation of the protection in
IntrospectionEndpoint.java is for demonstration purpose only,
and it is not suitable for commercial use. Therefore, modify the code
accordingly.

See Also
--------

- [Authlete][1] - Authlete Home Page
- [authlete-java-common][5] - Authlete Common Library for Java
- [authlete-java-common API][7] - JavaDoc of Authlete Common Library for Java
- [authlete-java-jaxrs][6] - Authlete Library for JAX-RS (Java)
- [authlete-java-jaxrs API][8] - JavaDoc of Authlete Library for JAX-RS (Java)

Contact
-------

| Purpose   | Email Address        |
|:----------|:---------------------|
| General   |<EMAIL_ADDRESS>  |
| Sales     |<EMAIL_ADDRESS> |
| PR        |<EMAIL_ADDRESS>    |
| Technical |<EMAIL_ADDRESS>|

[1]: https://www.authlete.com/
[2]: https://tools.ietf.org/html/rfc6749
[3]: https://openid.net/connect/
[4]: https://docs.authlete.com/
[5]: https://github.com/authlete/authlete-java-common
[6]: https://github.com/authlete/authlete-java-jaxrs
[7]: https://authlete.github.io/authlete-java-common/
[8]: https://authlete.github.io/authlete-java-jaxrs/
[9]: https://jcp.org/en/jsr/detail?id=339
[10]: https://openid.net/specs/openid-connect-core-1_0.html#AuthRequest
[11]: https://openid.net/specs/openid-connect-core-1_0.html
[12]: https://jersey.java.net/
[13]: https://www.authlete.com/documents/so_console/
[14]: ../src/main/java/com/authlete/jaxrs/server/api/AuthorizationEndpoint.java
[15]: https://authlete.github.io/authlete-java-jaxrs/com/authlete/jaxrs/AuthorizationRequestHandler.html
[16]: https://authlete.github.io/authlete-java-jaxrs/com/authlete/jaxrs/spi/AuthorizationRequestHandlerSpi.html
[17]: https://authlete.github.io/authlete-java-jaxrs/com/authlete/jaxrs/spi/AuthorizationRequestHandlerSpi.html#generateAuthorizationPage-com.authlete.common.dto.AuthorizationResponse-
[18]: ../src/main/java/com/authlete/jaxrs/server/api/AuthorizationRequestHandlerSpiImpl.java
[19]: https://authlete.github.io/authlete-java-jaxrs/com/authlete/jaxrs/spi/AuthorizationRequestHandlerSpiAdapter.html
[20]: https://authlete.github.io/authlete-java-common/com/authlete/common/dto/AuthorizationResponse.html
[21]: ../src/main/webapp/WEB-INF/template/authorization.jsp
[22]: https://authlete.github.io/authlete-java-common/com/authlete/common/types/Display.html
[23]: ../src/main/java/com/authlete/jaxrs/server/api/TokenEndpoint.java
[24]: https://authlete.github.io/authlete-java-jaxrs/com/authlete/jaxrs/TokenRequestHandler.html
[25]: https://authlete.github.io/authlete-java-jaxrs/com/authlete/jaxrs/spi/TokenRequestHandlerSpi.html
[26]: https://tools.ietf.org/html/rfc6749#section-4.3
[27]: ../src/main/java/com/authlete/jaxrs/server/api/TokenRequestHandlerSpiImpl.java
[28]: https://authlete.github.io/authlete-java-jaxrs/com/authlete/jaxrs/spi/TokenRequestHandlerSpiAdapter.html
[29]: ../src/main/java/com/authlete/jaxrs/server/api/AuthorizationDecisionEndpoint.java
[30]: https://authlete.github.io/authlete-java-jaxrs/com/authlete/jaxrs/AuthorizationDecisionHandler.html
[31]: https://authlete.github.io/authlete-java-jaxrs/com/authlete/jaxrs/spi/AuthorizationDecisionHandlerSpi.html
[32]: ../src/main/java/com/authlete/jaxrs/server/api/AuthorizationDecisionHandlerSpiImpl.java
[33]: https://authlete.github.io/authlete-java-jaxrs/com/authlete/jaxrs/spi/AuthorizationDecisionHandlerSpiAdapter.html
[34]: ../src/main/java/com/authlete/jaxrs/server/api/IntrospectionEndpoint.java
[35]: https://tools.ietf.org/html/rfc7662

repository: authlete/java-oauth-server

repo_name: authlete/java-oauth-server


text:
# ActionPrediction_NPSY2017_EEG

EEG Data Analysis Scripts for the 2017 Neuropsychologia paper Predictability of action sub-steps modulates motor system activation during the observation of goal-directed actions, available through DOI:10.1016/j.neuropsychologia.2017.07.009.

An overview of all the scripts used can be found in Scripts_Overview.txt

gha_language: MATLAB


text:
# Joyjet tech interview

This is a test to analyze knowledge in FrontEnd development, using specifics resources.

## Guidelines

- Follow all steps described here;
- The final project must be published to your BitBucket account;
- The link should be sent to email [jobs@joyjet.com](mailto:jobs@joyjet.com).

## Features

- Develop a ** Quiz ** application using React/VueJs/Angular depending on the role you are applying for;
- The user can register a quiz, questions and answers;
- A quiz may have several questions;
- A question may have several answers;
- When choosing a quiz, the user will be redirected to a page where he will list all the questions of that quiz and the answers to each question;
- When answering a question, you must tell whether the choice is correct or not;
- Each question must have at least 4 answers, one of them being the correct answer;
- Npm or yarn should be used to manage the dependencies;
- Create a README with installation guidelines;
- Choose a theme (Bootstrap, Foundation...);
- Use third-party libraries;
- Choose how you will save the data (local storage, database, json...);

## Differentials

- Use of Redux;
- Good use of components;
- Unit / functional tests;
- Commented code;

repository: dutraleonardo/work-at-joyjet

repo_name: dutraleonardo/work-at-joyjet


text:
---
title: Secondary control bar
description: The secondary control bar is the rectangular area that contains First and Last Page buttons and a Page Indicator when made available in CSS.
solution: Experience Manager
feature: Dynamic Media Classic,Viewers,SDK/API,eCatalog Search
role: Developer,User
exl-id: e5d6abe8-0ae9-4ccd-b311-5895e09310b2
---
# Secondary control bar{#secondary-control-bar}

The secondary control bar is the rectangular area that contains First and Last Page buttons and a Page Indicator when made available in CSS.

 By default, it is displayed on mobile phones only, in the bottom of the viewer. It always takes the whole available viewer width. It is possible to change its color, height, and vertical position by CSS, relative to the viewer container.

The appearance of the secondary control bar is controlled with the following CSS class selector:

`.s7ecatalogsearchviewer .s7secondarycontrols .s7controlbar`

 CSS property

Description

  top

Position from the top of the viewer.

  bottom

Position from the bottom of the viewer.

  height

The height of the main control bar.

  background-color

The background color of the secondary control bar.

Example - to set up a gray secondary control bar that is 72 pixels tall and is positioned at the bottom of the viewer container.

```
.s7ecatalogsearchviewer .s7secondarycontrols .s7controlbar {
 bottom: 0px;
 height: 72px;
}
```


text:
Date: 2013-07-23
Title: Python Packages for Graph Cuts on Images
Tags: python
Summary: Review of python packages for performing graph cuts on images.

Graph for a small image of 512x512 pixels has 261144 nodes and 523264 edges in the [4-connected pixels](http://en.wikipedia.org/wiki/Pixel_connectivity) case. Graphs in this scale require a fast construction interface. I reviewed a few python packages mainly from this perspective. The comparison is by no means exhaustive and fair!

# Based on Kolmogorov min-cut / max-flow C++ library
- original Kolmogorov's code: <http://vision.csd.uwo.ca/code/#Max-flow.2Fmin-cut>
- as of version 3.01 restricts usage only for research purposes
- version 2.21 can be [commercially licensed](http://www.e-lucid.com/i/software/optimisation_software/maxflow_computervision.html)

## PyMaxflow
- <https://github.com/pmneila/PyMaxflow>
- Cython based python interface
- well documented at <http://pmneila.github.io/PyMaxflow/>
- α-β-swap and α-expansion algorithms for multi-label optimization
- **shortcomings**:
    - missing batch addition of edges other than with constant weight

## pymaxflow
- <https://github.com/Rhoana/pymaxflow>
- Cython based python interface
- supports batch addition of edges from numpy arrays
    - edges are added one by one on the cython part of the interface, but it seems to be fast enough
- **shortcomings**:
    - not documented (but the package is so simple that it is not a big deal)
    - no algorithms for multi-label segmentation

Example of batch node and edge addition:

    im = ...
    g = pymaxflow.PyGraph()
    g.add_node(im.size)

    # linear indices of pixels arranged in image like matrix
    indices = np.arange(im.shape[0]*im.shape[1]).reshape(im.shape[0:2]).astype(np.int32)
    # compute differences between neighbouring pixels
    diffs = np.abs(im[:, 1:] - im[:, :-1]).ravel() + eps
    # indices of the neighbouring pixels
    e1 = indices[:, :-1].ravel()
    e2 = indices[:, 1:].ravel()
    g.add_edge_vectorized(e1, e2, diffs, diffs)

API:

    class PyGraph:
        __cinit__(self, int node_num_max, int edge_num_max)
        add_node(self, int num=1)
        add_edge(self, int i, int j, float cap, float rev_cap)
        add_tweights(self, int i, float cap_source, float cap_sink)
        maxflow(self)
        what_segment(self, int i)
        add_edge_vectorized(self,
                                np.ndarray[dtype=np.int32_t, ndim=1, negative_indices=False] i,
                                np.ndarray[dtype=np.int32_t, ndim=1, negative_indices=False] j,
                                np.ndarray[dtype=np.float32_t, ndim=1, negative_indices=False] cap,
                                np.ndarray[dtype=np.float32_t, ndim=1, negative_indices=False] rev_cap)
        add_tweights_vectorized(self,
                                np.ndarray[dtype=np.int32_t, ndim=1, negative_indices=False] i,
                                np.ndarray[dtype=np.float32_t, ndim=1, negative_indices=False] cap_source,
                                np.ndarray[dtype=np.float32_t, ndim=1, negative_indices=False] cap_sink)
        what_segment_vectorized(self)

## pygco
- based on Kolmogorov maxflow library and [gco library](http://vision.csd.uwo.ca/code/#Multi-label_optimization)
- source: <https://github.com/amueller/gco_python>
- introductory article written by the author: <http://peekaboo-vision.blogspot.cz/2012/05/graphcuts-for-python-pygco.html>
- cython based python interface
- well documented
- α-β-swap and α-expansion algorithms for multi-label segmentation
- supports only multi-label segmentation
- **shortcomings**:
    - no direct access to a low level functionality as the max-flow algorithm itself

## pygraphcut
- <http://tfinley.net/software/pygraphcut/>
- Python C API based interface
- **shortcomings**:
    - not actively developed
    - no public repository
    - no batch addition of nodes and edges
    - Python C API is hard to maintain
- I have not tested this package.

# Packages Based on Other Max-flow Implementations

## graph-tool library
- <http://projects.skewed.de/graph-tool/>
- perfectly documented and feature rich general graph algorithms package
- based on [Boost Graph](http://www.boost.org/doc/libs/1_54_0/libs/graph/doc/) library
- GPL license
- various max-flow algorithms including Kolmogorov's
- **shortcomings**:
    - *no batch addition of nodes and edges* - this shortcoming should be fixed now, see comment (22.10.2014)

One by one addition of nodes and edges implemented in Python is extremely slow for graphs in a scale suitable for images. In my experience ~100x slower than the *pymaxflow* package due to the graph construction.

## MedPy
- <https://pypi.python.org/pypi/MedPy/0.1.0>
- 3d graphcuts on voxels
- I have not tested this package.

# Conclusions

I picked the [pymaxflow](https://github.com/Rhoana/pymaxflow) package for my purposes. It's just simple but quick wrapper for the Kolmogorov min-cut / max-flow C++ library. The wrapper fairly minimalistic and is written in [Cython](https://en.wikipedia.org/wiki/Cython) that makes the bindings easy to understand and modify.

repository: smidm/home-page

path: /content/python maxflow packages.md

filename: python maxflow packages.md

repo_name: smidm/home-page


text:
---
layout: post
title:      "Parler Hack "
date:       2021-01-15 13:01:33 +0000
permalink:  parler_hack
---

I thought this would be a great and relevant post that we could all learn from in building our future applications.  Parler is an application used by far right groups and was most notably was thought to be used to organize fringe extremists during the capitol building assault.  Well it was hacked by activists and massive amounts of data has been collected on the individuals who used the app.

*But how?*

Parler seems to be put together quite amateurishly, because there are three strategies that these hackers used to collect the information they would use.  An exposed API, unscrubbed EXIF data and incremental post id's instead of random ones.

API's are essentially any part of your pipeline that can be accessed through an endpoint.  Typically I'll have my backend structured as an API that has several endpoints that can be accessed to retrieve relevant data on whatever it is the frontend needs.  Parler seems to not have password protected their endpoints, leaving open a slew of private data which was up for grabs.

Incremental post id's are another oddity that was left open for exploitation by hackers.  Apparently the post id's were not randomized, which meant that hackers could actually chronilogically sort posts and create a roadmap of what posts were created when.  This is important because it creates a standard amongst which other types of data can be linked.

Finally EXIF data is essentially metadata that gets linked to any sort of JPEG, TIFF or Image file that a program stores.  This data can give away important information on things like location or timestamps.  Typically this information gets scrubbed, but not in this case.

So in summation, a massive trove of private data was leaked because some pretty straightforward programming tennants were dismissed.