text:
# Internet Router Interoperability

[![Travis-CI Status](https://travis-ci.org/yale-build-a-router/internet-router-interop.svg?branch=master)][travis-ci]

This is a candidate repo for automatic [internet router
interoperability][cs634-project] test. To use it, please:

1. Create your internet router project following the format of the
   [example][ref-router].
2. Add your project as a submodule of this repo (under the `interop.p4app`
   directory).
3. Modify the `topo.json` file to configure your own switch.
4. Push your commit, then you can go to [Travic CI][travis-ci] to see the
   result of interoperability test.

The following sections describe some details about the implementation
guideline and configuration.

[cs634-project]: https://yale-build-a-router.github.io/documentation/internet-router/
[travis-ci]: https://travis-ci.org/yale-build-a-router/internet-router-interop
[ref-router]: https://github.com/fno2010/maclearning.p4app

## Create Mininet Switch Class Extending P4RuntimeSwitch

You should implement a python class extending `P4RuntimeSwitch`:

``` python
from p4_mininet import P4RuntimeSwitch

class MySwitch(P4RuntimeSwitch):
    def __init__(self, *opts, **kwargs):
        ...
        P4RuntimeSwitch.__init__(self, *opts, **kwargs)
```

The `__init__` method of this class should accept a `prog` argument for the
input P4 program at least.

> Note: This is the recommended way to implement your switch class. The
interoperability test program will rename the value of `prog` before it is
passed to your class to remove the potential naming conflict.
>
> You can also input your p4 program in your own way. But you should realize
the `prog` argument is reserved by the interoperability test program.

You should implement your control plane program and start it in the `start`
method of your switch class:

``` python
from p4_mininet import P4RuntimeSwitch

class MySwitch(P4RuntimeSwitch):
    ...

    def start(self, controllers):
        super(MySwitch, self).start(controllers)
        ...
        # start your own controller here
        self.controller = YourController()
        self.controller.start()
```

It is recommended to assign your control plane program instance to
`self.controller` attribute of your switch class. And your control plane
program should implement a `join` method to terminate a running session. The
interoperability test program will try to call `self.controller.join()` of
each running switch to stop the running controller session before the test
stopped.

Your control plane program should listen to a port of your switch. You should
provide some approach to allow mininet to specify this port number from the
`__init__` method of your switch class.

You can take a look at a [reference
implementation][ref-router] to better
understand how to implement your own switch class.

> **IMPORTANT:** you should create a `__init__.py` file (which can be empty)
in the top-level directory of your repo to make it a valid python module. The
interoperability test program will try to import it as a python module.

## Add Submodule to the Interop Repo

Then you can add your own repo to this interop repo as a submodule:

``` sh
# Clone this interop repo first
git clone https://github.com/fno2010/internet-router-interop
cd internet-router-interop

# Clone your own repo under the interop.p4app dir
pushd interop.p4app
# git clone <url_to_your_repo> <your_name>
git clone https://github.com/fno2010/pwospf jensen
popd

# Commit the submodule to the interop repo
# git submodule add <url_to_your_repo> interop.p4app/<your_name>
git submodule add https://github.com/fno2010/pwospf interop.p4app/jensen
git commit -m "Add jensen's pwospf router"
```

> Note: You should rename your repo to some custom name to avoid naming
conflict. The name should be a valid python module name (a valid identifier).

When you update your own router repo, you can go to the interop repo and pull
your submodule to the latest one.

``` sh
push interop.p4app/jensen
git pull
pop

git add .
git commit -m "Update jensen's pwospf router to v2"
```

## Configure Your Router in JSON

Then you should modify the `topo.json` file to configure some switch node to
use your own switch class.

``` json
{
  "switches": {
    "sw1": {
      "class": "example.maclearning.MacLearningSwitch",
      "prog": "/p4app/example/l2switch.p4",
      "enable_ctrl": true,
      "ctrl_args": {
        "ctrl_port": 1,
        "start_wait": 0.5
      }
    },
    ...
  },
  "hosts": { ... },
  "links": [ ... ]
}
```

The value of `class` should be `<your_module_name>.<your_class_name>` of your
own switch class. In this example, we assume your repo is renamed to
`example`, and you implement your class `MacLearningSwitch` in a python file
called `maclearning.py`.

The value of `prog` should be the path to your P4 program. If the path is
relative, the current working directory should be the `interop.p4app`
directory. If the path is absolute, you should replace the current working
directory to `/p4app`.

**If you want to use a control plane program, you MUST set `enable_ctrl` as
`true`.** It will ask the interoperability test program create a controller
interface for the switch automatically. The port number of this interface
will be `1`. So you should use your own approach to notify your own control
plane session this port number. In our reference implementation, we use
`ctrl_args` to pass the related arguments. It is not mandatory for your own
implementation.

All the attributes of this switch object in this JSON will be passed to the
`__init__` method of your own switch class. So you can do some customization
by yourself.

## Track the Interop Test in Travic CI

You don't have to do anything. Just push all your changes to the interop
repo. It will trigger the Travis CI to do test automatically.

``` sh
git add .
git commit -m "Add jensen's config to interop"
git push
```

Now go to [Travic CI][travis-ci] to see the result.


text:
# About
FoodNavigator is a simple Dashboard To explore building an IT solution for food research and development.
To start simple, we start with cooking an egg, the platform shows:
- an About Tab:
  - Information aboutwhat has been done, for example: What is an egg? Where did it come from, is it possible to measure it's Pollution footprints
- App: An interactive platform

# Ideas:
- Generate Recipes
- Generate Menu
- Generate Cost sheet
# Audience:
- Chef
- Scientist

license: MIT

repository: Janidai/FoodNavigator

branch_name: refs/heads/main

extension: md

license_type: permissive

repo_name: Janidai/FoodNavigator


text:
# chrome-rtf-viewer
This chrome extension allows to view RTF (Rich Text Format) files in the browser and does so automatically when clicking any link to an RTF file. The RTF file is then automatically rendered in the same tab (similarly to the pdf preview feature of most browsers). This plugin does not depend on any external services to generate the preview.

You can install this extension from https://chrome.google.com/webstore/detail/rtf-viewer/djalaeippddcgflofefafkgijpefkjef

# License
This project is licensed under the MIT license. See the LICENSE file for details.

# Dependencies
This project uses [rtf.js](https://github.com/tbluemel/rtf.js) for rendering the RTF files. rtf.js and its dependecies are included in the 'external' folder for convenience.

repository: tclancy/chrome-rtf-viewer

branch_name: refs/heads/master

repo_name: tclancy/chrome-rtf-viewer


text:
# Electron iframe resize example

This project is an example project that we can toggle the width of an iframe in an electron container.
This also proves that the content of the iframe can be designed in a responsive way.

## Get started

```bash
# clone the repo
git clone https://github.com/samvloeberghs/electron-iframe-resize-example.git

# change directory to our repo
cd electron-iframe-resize-example

# install the repo with npm
npm install

# start the app
electron .
```

## Packaging the app

To package the app and run it as an exe you first need to install the packager globally.

```bash
# install packager
npm install electron-packager -g

# start packaging
npm run package
```

repository: samvloeberghs/electron-poc

repo_name: samvloeberghs/electron-poc


text:
# Splunk SDK for C# PCL

## Version 2.1.2

## Bug fixes
* Search and job operations now default to a count of 0, which represents all.

## New examples
* `Get-SplunkDataInputs`: Shows how to access an unsupported REST API endpoint.

## Minor changes
* The GitHub commits example now uses the Json.NET library instead of a dictionary.
* Modular input validation now logs exceptions as `INFO` instead of `DEBUG`.
* Added xunit.runner to the `packages` directory.

## Version 2.1.1

### Fixes
* Removed `All` and `Scheme` attach points for debugging Modular Inputs.
* Hardened logging for Modular Inputs:
  * Added more contextual information.
  * Ensured all exceptions are captured and logged.

## Version 2.1.0

### New Features
* Add the GitHub commits modular input example.
* Add support for Xamarin Forms.
* Add support for remotely debugging modular inputs with Visual Studio.

### Minor changes
* Building a modular input example no longer creates its `.spl` file.
* `Job` returns all available results by default if no arguments are passed to `Job.GetSearchResultsAsync()`, `Job.GetSearchPreviewAsync()`, and `Job.GetSearchEventsAsync()`.
* `Service` now uses interfaces in place of implementations in order to improve testability.
* Add a `ModularInputs/EventWriter.LogAsync()` overload that takes a `Severity` enum as a parameter.
* Add a `Service` constructor that takes a `Uri` as a parameter.

## Version 2.0.0
* Add ConfigureAwait(false) to all await calls in the library to prevent some deadlocks in user code.
* Add User-Agent string to HTTP requests.

## Version 2.0.0 pre-release

* Initial release.

repository: brattonc/splunk-sdk-csharp-pcl

repo_name: brattonc/splunk-sdk-csharp-pcl


text:
---
layout: post
title: Parsing text files with different formats
---
## The problem
The first stage of my work was to study how to read and recognize the content of different logs. I faced the situation when each part of the system has its own log format, and different versions may have slightly different formats:

	...
	2010-10-10 12:10:10,000 Warning [Some information] Message text
	...
	Info::2010-10-10 12:10:10,000::(Some index)::[Some information] Message text (Some other code)
	...

I had several ideas about solving this task, and I'd like to share the results. We discussed two opportunities for recognizing different formats:

- read a file line-by-line and collect the repeated information in the lines, that represents the format. Separators, their
number and order would make the template for a log file line

- define a template manually for each format. This method assumes the user to add a new template if a new format appears to be analyzed, but the advantage is in saving time with no need to pre-read each log to construct the format template.

To avoid unexpected difficulties I've implemented the second approach and left the possibility to create an automatic template-building.

## Simple solution
I used regular expression to define the file template. There are named fields with possible characters and separators in the templates, and all these constraints I've received after testing them on different log files that I have. On this stage on-line regular expression editor [Pythex](http://pythex.org) helped me a lot. After I have received a templates that matches only "their" formats, I've placed them in order from the most detailed (with many constrains) to the most common. I would spend a couple of days on this task, if there were no other difficulties.

## Facing difficulties
Since I analyze the log files, I can expect that each message would match the template of the format (no). So some lines suddenly does not match the template. We want to save as much information as we can, so it is better to parse them somehow of at least save the raw line. I list some of the examples when a line differs from the log file format:

#### *Disappering of date and time*
	...
	2010-10-10 12:10:10,000 Warning [Some information] Message text
	Warning: some warning text
	2010-10-10 12:10:10,500 Info [Some information] Message text
	...

I found out that not all log file lines include a date+time label. For example, some system messages, that could appear in any time between the previous and following log messages. The idea of processing such cases is in copying the date and time from the previous message and noticing it in the text of the parsed line. So if the date and tine was not detected in the log line, the line is sawed in a raw format and required fields are copied from the previous message. But even if the date+time is found it doesn't mean that the line will be matched.

#### *Disappering of date and time and it's appearing on the other place in the line*
	...
	2010-10-10 12:10:10,000 Warning [Some information] Message text
	Warning: some warning text about 2010-05-24 18:30:16,400 date and time action
	2010-10-10 12:10:10,500 Info [Some information] Message text
	...

We can found a date+time in a log line, but it is not located in the defined place for date times and just represents some other date+time in the message that is not related to the time of the line was written to the log file. All we can do is to try to match full line with the file format template and handle the exception, which would tell us about the wrong location of the date+time. The processing of this case also involves copying information from the previous message.

#### *One of the line fields includes `\n`*
	...
	2010-10-10 12:10:10,000 Warning [Some information] Message text
	and it's continuation
	and more continuation
	and ending

	2010-10-10 12:10:10,500 Info [Some information] Message text
	...

The most simple case is when the last line field become miltiline (common example -- Tracebacks). Then the line will match the template as on this step we don't know anything about the next line and it's relation to the current line. So if we read the line and parse it, and then found out that the next line does not match the template, we should concatenate it with the previous line, and do it until we read the "normal" matched line. This means that we should store the line until we make sure that we've read the full message.

The more complex case is when the non-last field become multiline and moves the template-required fields of the message to another line.

	...
	2010-10-10 12:10:10,000 Warning [Some information] Message text
	and it's continuation
	and (Some other code)

	2010-10-10 12:10:10,500 Info [Some information] Message text (Some other code)
	...

What do we see in this situation? The first line conclude the date+time, but does not match the template -- the explanation coincides the second case, but represents the other situation that can be solved. The idea is again to concatenate the lines until we reach the "normal" line, and then try to match the constructed line to the template. If there were lost fields, they will be found, and if the situation was about disappeared date+time, we will do the instructions from that case.

#### *Combination of several exceptions*
	...
	2010-10-10 12:10:10,000 Warning [Some information] Message text
	and it's continuation
	and more continuation about 2010-05-24 18:30:16,400 date and time action
	and ending
	and (Some other code)

	Warning: some warning message
	2010-10-10 12:10:10,500 Info [Some information] Message text (Some other code)
	...

Of course during solving all the described non-standard situations I have been searching for their combinations and tested the implemented algorithm for them. One of the features of the parsing algorithm is in the constrains that the user could impose to it. For example, he or she could provide a date and time range in which the log messages are to be showed or define a particular keyword that should be a part of a message. So the analyzer do not have to process and store all rows, only those that correspond to conditions. And we have to check the conditions after we parse the whole message, because the found date+time could not relate to the message appearance, and the keywords could be located on the non-first line of the message, if it contains `\n`.

## Conclusion
The process of solving this problem was interesting and unusual for me. During scientific work and studies it turns out that you have a tiny bit of standardized data over which you need to write a lot of different things. But in is the case you have 100 lines of algorithm and you improve and modify them because every time there appears a new case, Which must be taken into account. The next stage promises to be more familiar to me and I will do my best and hope to meet expectations for the result.


text:
---
layout: default
---

# 1997-01-14 - Multi-drop quantum cryptography article in Nature 385, 47-49 (1997)

## Header Data

From: Paul Pomes<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 590eeca3692c40595d71677ec7b2d38d4d5dbbe7e457f393af674b7128307e8c

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1997-01-14 15:43:29 UTC

Raw Date: Tue, 14 Jan 1997 07:43:29 -0800 (PST)

## Raw message

```
{% raw  %}From: Paul Pomes<EMAIL_ADDRESS>Date: Tue, 14 Jan 1997 07:43:29 -0800 (PST)
To<EMAIL_ADDRESS>Subject: Multi-drop quantum cryptography article in Nature 385, 47-49 (1997)
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

(Reproduced from <http://www.nature.com>)

Eavesdropping on the line

Secure electronic communication is becoming increasingly important. In
recent years, quantum cryptography has been investigated as a means of
detecting eavesdroppers on private lines. When quantum mechanical processes
are used to establish the 'key' used for encryption and decryption, any
eavesdropping during transmission leads to an unavoidable and detectable
disturbance in the received key information. This technique has been
demonstrated to be effective on standard communication lines between two
users, but Paul D. Townsend now introduces a practical scheme for a
multi-user network. This work demonstrates the technical feasibility of
quantum cryptography for practical applications.  P D Townsend Quantum
cryptography on multi-user optical fibre networks (Letter to Nature) Nature
385, 47-49 (1997)

{% endraw %}
```

## Thread

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

+ Return to "[Paul Pomes <ppomes@Qualcomm.com>](/authors/paul_pomes_ppomes_at_qualcomm_com_)"

+ 1997-01-14 (Tue, 14 Jan 1997 07:43:29 -0800 (PST)) - Multi-drop quantum cryptography article in Nature 385, 47-49 (1997) - _Paul Pomes<EMAIL_ADDRESS>

gha_license_id: MIT


text:
# OpenDialog Local Development

This package helps you get setup for local development using Docker. It is based on the [Laradock](https://laradock.io) project with (most) unnecessary components removed and allows you to spin up OpenDialog using pre-made docker images from Laradock, the standard [Dgraph](https://dgraph.io) images and the OpenDialog source code.

We first walk through setting up the Docker environment and then setting up OpenDialog within that environment.

## Setup Docker Environments

To deploy OpenDialog using this package run through the following steps:

+ Make sure the environment you are going to be working in (locally or on a VM) has Docker and Git installed

+ Create a directory called `od-app` (or whatever you prefer to call it, ensuring that any references of od-app in the documentation that follows is replaced by the name you chose).

+ Clone the OpenDialog [appication](https://github.com/opendialogai/opendialog) in a directory called `opendialog` (or your own app name) within od-app.

`git clone git@github.com:opendialogai/opendialog.git opendialog`

+ Clone the OpenDialog Deploy package (i.e. this package), in a directory named `opendialog-development-environment`.

`git clone git@github.com:opendialogai/opendialog-dev-environment.git`

+ The folder structure should be (the names of the directories are important, if you change them to match your project name please follow through in all the other parts mentioned in this doc):

  ```
     + od-app
     ++ opendialog
     ++ opendialog-development-environment
   ```

+ Create a copy of `opendialog-development-environment/nginx/sites/opendialog.conf.example` in the same directory, and create `opendialog.conf` (or your own app name). This is your new vhost file, that handles nginx config.
  Make sure the `server_name` is using the URL you want to use locally and that `root` is pointing to the correct directory (the `public` directory of the OpenDialog application cloned from GitHub). If you are not changing any of the defaults no change is required.
+ Add the server name that you defined in the nginx configuration to /etc/hosts (e.g. `<IP_ADDRESS> opendialog.test` )
+ Copy `env.example` to `.env`.
+ Change the `DATA_PATH_HOST` to `DATA_PATH_HOST=~/.laradock/opendialog/data` - this ensures that each application will have its own data directory so data will not be shared between multiple installations of OpenDialog apps.
+ Modify COMPOSE_PROJECT_NAME to match `opendialog` (or your own app name) - this ensures that you are using different containers for each OpenDialog application.
+ Set `MYSQL_ROOT_PASSWORD` and `MYSQL_PASSWORD` to appropriate values (you will use this when setting up OpenDialog itself as well)
+ If you change the value of `MYSQL_USER`, update the user in `mysql/docker-entrypoint-initdb.d/createdb.sql`

### Starting up the environment

From withing opendialog-development-environment start all the containers with:

    `docker-compose up -d`

Please note that if you have another OpenDialog application up and running you may need to stop those containers in order to avoid port clashing.

This will start all containers including `workspace`,  `dgraph ratel`, `dgraph-zero-test` and `dgraph-server-test` which are not needed to just test an application. To run just the required containers, run

    `docker-compose up -d php-fpm mysql nginx dgrah-zero dgrarh-server memcached`

To connect to the workspace container to run scripts use:
`docker-compose exec workspace bash`.

You are now ready to setup OpenDialog itself.

## Setting up OpenDialog

+ Connect to the workspace container as described above and run the following commands to set the application up:

in `/var/www/opendialog`:

* run `composer install`
* run `cp .env.example .env; php artisan key:generate;`
* Edit .env file and configure the app name, URL and DB settings
    * Use the database credentials you defined above.
    * Use 'mysql' for MySQL host
    * Use `dgraph-server` for the DGraph host
* run `php artisan migrate` to setup tables
* run `php artisan user:create` to create a user
* run `bash update-web-chat.sh -iy` to build the webchat widget for interacting with the bot
* run `php artisan webchat:setup` to setup default values for webchat
* run `php artisan conversations:setup` to setup default conversations
* run `yarn install` and `yarn run dev` to setup the admin interface

### Confirm OpenDialog works

To ensure that it is all working visit http://opendialog.test, you should see the OpenDialog welcome screen and be able to login with the user you created. If you visit http://opendialog.test/admin/demo the bot should load in the page and give you the default welcome message.

### Confirm Dgraph works

To ensure that Dgraph is working visit http://opendialog.test:9001/?latest and point it to http://opendialog.test:8080

You should be able to use the console to run queries such as:

``{
  node(func: eq(ei_type,"conversation_template")) {
    uid
    expand(_all_)
  }
}``

## Automated testing

To run automated tests with PHPUnit first ensure that phpunit.xml has the correct information for connecting to Dgraph.

`
<env name="DGRAPH_URL" value="dgraph-server-test"/>
<env name="DGRAPH_PORT" value="8082"/>
`

You can then run `phpunit`

Keep in mind that this uses a separate Dgraph instance so it will not be changing any data that the application itself is using.

## Setting up xDebug

- Open the .env file, search for `WORKSPACE_INSTALL_XDEBUG` and set it to `true`
- Still in .env, search for `PHP_FPM_INSTALL_XDEBUG` and set that to `true`
- Rebuild the containers with `docker-compose build workspace php-fpm`

## Configuring PHPStorm

The OpenDialog team is primarily on PhpStorm but these instructions should give you a sense of what is required for any similar IDE.

- In Preferences > Languages & Frameworks > PHP next to the CLI Interpreter drop-down click on the three dotted lines to add a new interpreter.
- Click on + and select "From Docker, Vagrant, VM Remote"
- In the "Configure Remote PHP Interpreter pop-up select Docker Compose"
- Then add the Docker Compose configuration file that is in opendialog-development-environment.
- PhpStorm will automatically pick-up the available services, select `workspace` from the drop-down. Confirm to close the pop-up.
- In CLI Interpreters next to "php executable" click the reload phpinfo button. If that is succesfully retrieves the phpinfo you are one step closer.
- Confirm the interpreter and in the following page add path mappings from whatever your local path is to the root of the OpenDialog application to `/var/www/opendialog/`.
- Next go to Preferences > Languages & Frameworks > PHP > Test Frameworks and add 'PHPUnit by Remote Interpreter' and select the `workspace` interpreter.
- Make sure that "Use Composer Autoloader" is selected and add `/var/www/opendialog/vendor/autoload.php` as the path to script.
- Hit Refresh next to the "Path to Script" field. If it correctly identifies the PHPUnit version installed you should be good to go.

## Local Package Development

The `packages:install` artisan command will checkout and symlink `opendialog-core` and / or `opendialog-webchat` to a `vendor-local` directory.

To install dependencies using it, you can run `artisan packages:install`. You will be asked if you want to use local versions of core and webchat.
If so, you can now use, edit and version control these repositories directly from your `vendor-local` directory.

After doing so, you may need to run `php artisan package:discover` to pick up any new modules.

Note:
Before a final commit for a feature / fix, please be sure to run `composer update` to update the `composer-lock.json` file so that it can be tested and deployed with all composer changes in place

### Reverting

To revert back to the dependencies defined in `composer.json`, run the `artisan packages:install` command again and answer no to installing core and webchat locally.

## Running Code Sniffer
To run code sniffer, run the following command
```./vendor/bin/phpcs --standard=od-cs-ruleset.xml app/ --ignore=*/migrations/*,*/tests/*```

## Git Hooks

To set up the included git pre-commit hook, first make sure the pre-commit script is executable by running

```chmod +x .githooks/pre-commit```

Then configure your local git to use this directory for git hooks by running:

```git config core.hooksPath .githooks/```

Now every commit you make will trigger php codesniffer to run. If there is a problem with the formatting
of the code, the script will echo the output of php codesniffer. If there are no issues, the commit will
go into git.


text:
# Chen-Mangasarian-loss

## Definition

This repo contains Keras implementation of Chen Mangasarian Loss [1], and an example notebook to use it.

Pinball Loss is defined by:

![Pinball](https://github.com/Demangio/chen-mangasarian-loss/blob/main/pictures/pinball.PNG?raw=true)

This loss is continuous but non differenciable everywhere, that's why it can't be used to backpropagate Neural Networks.

Chen Mangasarian Loss is a C2 approximation of Pinball Loss, defined by:

![Chen Mangasarian](https://github.com/Demangio/chen-mangasarian-loss/blob/main/pictures/chen_manga.PNG?raw=true)

Where alpha is the quantile probability (between 0 and 1 excluded), x the difference between quantile value and observed value, and a is a smoothing parameter.
Chen and Mangasarian have demonstrated that when a -> 0, their loss tends to Pinball Loss.

In addition to that, the loss was offset to keep the same minimum as Pinball for every quantile. It gave the best results in my own applications. Offset value is:

![Chen Mangasarian offset](https://github.com/Demangio/chen-mangasarian-loss/blob/main/pictures/offset_chen.PNG?raw=true)

Here is a plot to illustrate smoothing:

![](https://github.com/Demangio/chen-mangasarian-loss/blob/main/pictures/plot.PNG?raw=true)

## Keras implementation

In the example notebook, both losses (Pinball/Chen Manga) are implemented, first as metric, second as Loss.

You have to find the best a parameter in order to get the best results while keeping convergence.

Network has as many outputs as the number of quantiles.

[1] C., & Mangasarian, O. L. (1996). A class of smoothing functions for nonlinear and mixed complementarity problems. Computational Optimization and Applications, 5(2), 97–138. https://doi.org/10.1007/BF00249052

repository: Demangio/chen-mangasarian-loss

repo_name: Demangio/chen-mangasarian-loss


text:
---
layout: post
title: SAP and Google Wave - Conversation Augmentation
tags:
- appengine
- dashboard-tag
- http
- python
- rest
- sap
- wave
---

It’s been pretty much six years to the day since [I last wrote here about Dashboard](/tag/dashboard/), Nat Friedman’s project and implementation of a realtime contextual information system. So I thought it fitting to make a short demo showing integration between Google Wave and SAP, inspired by the cluepacket-driven style shown so nicely with Dashboard.

I got my Wave Sandbox account a week or so ago, and have had a bit of time to have a look at how robots and gadgets work — the two main Wave extension mechanisms. To get my feet wet, I built a robot, which is hosted in the cloud using Google App Engine, another [area of interest to me](/tag/appengine/), and the subject of this weblog entry. I used Python, but there’s also a Java client library available too. You can get more info in the [API Overview](http://code.google.com/apis/wave/guide.html).

What this robot does is listen to conversations in a Wave, automatically recognising SAP entities and augmenting the conversation by inserting extra contextual information directly into the flow. In this example, the robot can recognise transport requests, and will insert the request’s description into the conversation, lending a bit more information to what’s being discussed.

The robot recognises transport requests by looking for a pattern:

trkorr_match = re.search(' (SAPKw{6}|[A-Z0-9]{3}Kd{6}) ', text)

In other words, it’s looking for something starting SAPK followed by six further characters, or something starting with 3 characters, followed by a K and six digits (the more traditional customer-orientated request format). In either case, there must be a space before and a space following, to be more sure of it being a ‘word’.

How does it retrieve the description for a recognised transport request? Via a simple REST-orientated interface, of course :-) I use the excellent Internet Communication Framework (ICF) to build and host HTTP handlers so I can [expose SAP functionality and data as resources in a uniform and controlled way](https://www.sdn.sap.com/irj/scn/weblogs?blog=/pub/wlg/584). Each piece of data worth talking about is a [first class citizen on the web](/blog/posts/2009/06/29/information-vs-behaviour/); that is, each piece of data is a resource, and has a URL.

So the robot simply fetches the default representation of the recognised request’s ‘description’ resource. If the request was NSPK900115, the description resource’s URL would be something like:

http://hostname:port/transport/request/NSPK900115/description

Once fetched, the description is inserted into the conversation flow.

<object data="http://www.youtube.com/v/G7W2M6H3OQo&hl=en&fs=1&" height="340" type="application/x-shockwave-flash" width="560"><param name="allowFullScreen" value="true"></param><param name="allowscriptaccess" value="always"></param><param name="src" value="http://www.youtube.com/v/G7W2M6H3OQo&hl=en&fs=1&"></param><param name="allowfullscreen" value="true"></param></object>

[http://www.youtube.com/watch?v=G7W2M6H3OQo](http://www.youtube.com/watch?v=G7W2M6H3OQo)

([Originally written on SDN](http://weblogs.sdn.sap.com/pub/wlg/15721) but republished here because of portal access issues)

gha_language: CSS


text:
# Intel x86/x86_64 instruction set exporter

This program exports instructions based on the set names received from Intel Intrinsics Guide webpage.
XML is downloaded from the page, it can be updated whenever a new set lands.
It exports the list as markdown format to track implementation in checklist format.

## Usage

```bash
$ python instexport.py <SETNAME>
```

Like:
```bash
$ python instexport.py AVX512BW
```

For any update you see, please open a PR.

## License
Unlicense

license: Unlicense


text:
###  EKS Logs Collector

This project was created to collect Amazon EKS log files and OS logs for troubleshooting Amazon EKS customer support cases.

#### Usage
Run this project as the root user:
```
curl -O https://raw.githubusercontent.com/nithu0115/eks-logs-collector/master/eks-log-collector.sh
sudo bash eks-log-collector.sh
```

Confirm if the tarball file was successfully created (it can be .tgz or .tar.gz)

#### Retrieving the logs
Download the tarball using your favourite Secure Copy tool.

#### Example output
The project can be used in normal or enable_debug(**Caution: enable_debug will prompt to confirm if we can restart Docker daemo which would kill running containers**).

```
# sudo bash eks-log-collector.sh --help
USAGE: eks-log-collector --mode=collect|enable_debug
       eks-log-collector --help

OPTIONS:
     --mode  Sets the desired mode of the script. For more information,
             see the MODES section.
     --help  Show this help message.

MODES:
     collect        Gathers basic operating system, Docker daemon, and Amazon
                    EKS related config files and logs. This is the default mode.
     enable_debug   Enables debug mode for the Docker daemon
```
#### Example output in normal mode
The following output shows this project running in normal mode.

```
sudo bash eks-log-collector.sh

	This is version 0.0.4. New versions can be found at https://github.com/awslabs/amazon-eks-ami

Trying to collect common operating system logs...
Trying to collect kernel logs...
Trying to collect mount points and volume information...
Trying to collect SELinux status...
Trying to collect iptables information...
Trying to collect installed packages...
Trying to collect active system services...
Trying to collect Docker daemon information...
Trying to collect kubelet information...
Trying to collect L-IPAMD information...
Trying to collect sysctls information...
Trying to collect networking infomation...
Trying to collect CNI configuration information...
Trying to collect running Docker containers and gather container data...
Trying to collect Docker daemon logs...
Trying to archive gathered information...

	Done... your bundled logs are located in /opt/log-collector/eks_i-0717c9d54b6cfaa19_2019-02-02_0103-UTC_0.0.4.tar.gz
```

repository: otoolema/eks-logs-collector

repo_name: otoolema/eks-logs-collector


text:
---
title: Design Time
page_title: Design Time - WinForms TabbedForm
description: Learn what are the design time options of the WinForms TabbedForm.
slug: radtabbedform-design-time
tags: radtabbedform
published: True
position: 2
---

## Design Time

At design time you can directly type on the left or right part to add buttons.

>caption Figure 1: RadTabbedForm Add Buttons to the Left or Right

![WinForms RadTabbedForm Design Time](images/radtabbedform-design-time002.png)

>important When the content area or a tab is selected you cannot resize the form. Just pres __Esc__ and the parent form will be selected.

## Smart Tag

>caption Figure 2: RadTabbedForm Smart Tag

![WinForms RadTabbedForm Smart Tag](images/radtabbedform-design-time001.png)

* __Common Tasks__
    - __New Theme Manager:__ Adds a new __RadThemeManager__ component to the form.
    - __Edit UI elements:__ Opens a dialog that displays the __Element Hierarchy Editor.__ This editor lets you browse all the elements in the control.
    - __Theme Name:__ Select a theme name from the drop down list of themes available for that control. Selecting a theme allows you to change all aspects of the controls visual style at one time.
* __TabbedFormControl Tasks__
    - __Caption Height:__ Set the height of the entire title bar.
    - __Tab Height:__ Set the height of all tabs.
    - __Tab Spacing:__ Set the space between the tabs.
    - __Tab Width:__ Set the width of all tabs.
    - __Minimum Tab Width:__ Set the minimum tabs width.
    - __Pinned Items Position:__ Set the position of the pinned tabs.
    - __Tab Item Drag Mode:__ Set the drag drop mode.
* __Tabs__
    - Add or remove tabs.
* __Learning Center:__ Navigate to the Telerik help, code library projects or support forum.
* __Search:__ Search the Telerik site for a given string.

# See Also

* [Structure]({%slug radtabbedform-structure%})
* [Getting Started]({%slug  radtabbedform-getting-started%})

repository: telerik/winforms-docs

gha_language: JavaScript

repo_name: telerik/winforms-docs


text:
# Status Report

#### Your name

Corinne Margel

#### Your section leader's name

Joanne Nichols

#### Project title

2048

***

Short answers for the below questions suffice. If you want to alter your plan for your project (and obtain approval for the same), be sure to email your section leader directly!

#### What have you done for your project so far?

So far, we have the framework for the 2048 grid. We also added keyboard input to move and functions to merge blocks on the grid, shift the board in a given direction, and detect if the user has the 2048 tile.

#### What have you not done for your project yet?

We have not added a GUI for the game or debugged the currents functions/combined them in a way that the user can complete a full game of 2048.

#### What problems, if any, have you encountered?

We had problems setting up the grid, which were then resolved by changing the way it was coded. Currently, we are having problems setting up the GUI with pygame.


text:
# **Finding Lane Lines on the Road**

## Writeup Template

### You can use this file as a template for your writeup if you want to submit it as a markdown file. But feel free to use some other method and submit a pdf if you prefer.

---

**Finding Lane Lines on the Road**

### Reflection

### 1. Describe your pipeline. As part of the description, explain how you modified the draw_lines() function.

My pipeline consisted of 5 steps.

#### Original image)
 ![org](test_images/solidWhiteRight.jpg)

#### 1st step) I converted the images to grayscale for the following processing.
 ![1st](test_images_output/gray.jpg)

#### 2nd step) Grayscale image was made smooth by Gaussian smoothing.
 ![2nd](test_images_output/blur_gray.jpg)

#### 3rd step) Canny edge detection was applied to smoothed gray image.
 ![3rd](test_images_output/edges.jpg)

#### 4th step) Masking the image of edge via the trapezoidal window to extract area of lane-line.
Position of each vertices were tweaked for better line detection.
 ![4th](test_images_output/masked_edges.jpg)

#### 5th step) Hough transformation and drawing lines.
In order to draw a single line on the left and right lines, I separated the output of "cv2.HoughLinesP" into two groups.
If the slope of line is positive, then that is right line. If the slope is negative, then left line.
Addtionally, I set allowable range of values for each slope, in order to exclude noise.
 ![5th](test_images_output/image_with_lines.jpg)

-------------------------------------------------------------------
Using above pipeline, lane lines are drawn onto video recording of camera on board.

#### case#1) White lane on the right, dotted lane on the left
[![IMAGE ALT TEXT HERE](http://img.youtube.com/vi/b81yoZ0RB8U/0.jpg)](http://www.youtube.com/watch?v=b81yoZ0RB8U)

#### Case#2) Yellow lane on the left, white lane on the right
[![IMAGE ALT TEXT HERE](http://img.youtube.com/vi/T8FMgaICWqw/0.jpg)](http://www.youtube.com/watch?v=T8FMgaICWqw)

## 2. Identify potential shortcomings with your current pipeline

### Shortcomings)
In the middle of "challenge.mp4", left lines cannot be detected for short period.
[![IMAGE ALT TEXT HERE](http://img.youtube.com/vi/uX9V763bVdA/0.jpg)](http://www.youtube.com/watch?v=uX9V763bVdA)

## 3. Suggest possible improvements to your pipeline

A possible improvement would be to tweak parameters of gaussian, canny and hough transform.


text:
# BioCompute Object Creator

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

This is a tool to create a BioCompute Object directly from the command line.

This tool creates an IEEE compliant [IEEE-2791 object](https://opensource.ieee.org/2791-object/ieee-2791-schema/).

## Table of Contents

- [Background](#background)
- [Install](#install)
- [Usage](#usage)
- [API](#api)
- [Documentation](#documentation)
- [Issues](#issues)
- [Contributing](#contributing)
- [License](#license)

## Background

BioCompute is a standardized way to communicate an analysis pipeline. BioCompute substantially improves the clarity and reproducibility of an analysis, and can be packaged with other standards, such as the Common Workflow Language. An analysis that is reported in a way that conforms to the BioCompute specification is called a BioCompute Object (BCO). A BCO provides the structure that dictates what information must be present in a report.

Additional BioCompute resources can be found [here](https://biocomputeobject.org/)

## Install

This tool's dependencies include the `jsons` package in python which can be installed with `python3 -m pip install jsons`

Download this tool's [code](https://github.com/p-m-ishra/BioComputeObjectCreatorCommandLineTool/blob/master/biocompute_command_line_tool.py) from github in same directory where you intend to use it or use the following command:

```
wget https://raw.githubusercontent.com/p-m-ishra/BioComputeObjectCreatorCommandLineTool/master/biocompute_command_line_tool.py
```

If you would like to clone this repository:

```
git clone https://github.com/p-m-ishra/BioComputeObjectCreatorCommandLineTool.git
```

## Usage

* Current Prerequisiteshttps://drive.google.com/file/d/1NPw-CcfMkGLqKFbO7OPF9djmEmE3HjoW/view?usp=sharing)
  * Pipeline must be on first line of input after script started message (E.g. after this line: `Script started on 2020-08-01 15:21:02-0400`)
  * Pipeline must be one line long
  * Symbol after working directory must be $ or # (E.g. `pranav@laptop:~$` or `root@laptop:~#`)

This tool's walkthrough/demo can be found [here](https://youtu.be/lzyoe3MEJeg).

Place `biocompute_command_line_tool.py` in the same directory as the output of the `script` command that recorded the computational workflow or analysis pipeline.

Then run the following command:
```
python3 biocompute_command_line_tool.py
```

Navigate to [BioCompute Portal](https://portal.aws.biochemistry.gwu.edu/bco/new/form#!)

Click `edit json` and paste the output from the json file.

Finally, click `submit` to create your BioCompute Object.

## API

## Documentation

**Classes and Objects**
For each domain, there is a class with all required and optional fields in that domain. Additionally, some subdomains have their own classes as they have their own specific fields. Items in an array also have their own class if they have multiple fields (E.g. parameter object fills the parametric domain array) Optional fields are set to NoneType if the user opts not to enter them. Currently, the user is not prompted to enter optional fields. The remove_nulls method insures that NoneType fields are not included in the output json file.

**Automatic Pipeline Breakdown**
To read in the output script file, the first line (E.g. `Script started on 2020-08-01 15:21:02-0400`) is cut from the input text and the pipeline is defined as the first occurence of a $ or # to the next occurence of a newline (\n) character.

In the following example from the [example input file](https://github.com/p-m-ishra/BioComputeObjectCreatorCommandLineTool/blob/master/biocompute_input.txt), the first line would be cut and then ` cat input.txt | grep "ham" | sed -n '/ham?$/p' > output.txt` would be the pipeline.

```
Script started on 2020-08-01 15:21:02-0400
pranav@LAPTOP-CHO8EET5:/mnt/c/Users/pranav/Documents/GWU/BioCompute$ cat input.txt | grep "ham" | sed -n '/ham?$/p' > output.txt
```
For the description domain, pipeline steps are identified by splitting by the `'|'` character. Each step is now part of a list. Then, each individual step is split by the `' '` character and the first item of the resulting list is registered as the tool. Users are able to confirm and edit the tool name in case the automatic prediction is incorrect.

For the parametric domain, pipeline steps are identified the same way. Then, a non-default parameter is identified through the presence of a `" -"` expression in the step. If that expression is present, the tool name is identified by splitting by the `' '` character and taking the first item in the resulting list. The non-default parameter value is identified by taking the remaining string, finding the index of the `" -"` expression and then cutting the aforementioned remaining string into the index of that expression to the next occurence of a `' '` character. Users are given an option to delete and edit automatically identified parameters. They are also able to add parameters that were not automatically identified.

**User Input**
When user enters input separated by spaces, it is either broken into a list or put into a dictionary as a key:value pair. Most input that needs to be in a certain format has a try except block in order to make sure user can retry if they do not enter it in the correct format the first time. For fields that are not self-explanatory, the users receive a description describing what they should put into that field through a print statement. For fields that are not free text fields, the user receives directions on how to enter their input through a print statement.

While loops are used when users can add multiple inputs into a field that takes an array. The user is prompted after each input whether they would like to add another item.

**File Saving**
First, the output file is saved without the etag, object_id, and spec_version fields. Then based on prior user input, it is hashed with MD5, SHA1, or SHA256. Then, the json file is resaved with the object_id, spec_version, and newly autogenerated etag. All intermediate (When file is saved without metadata fields) and final (final output file) file saving occurs in try except blocks and alerts user if there is an error saving the file.

## Issues

* Prompt user if they would like to change anything at the end
* Check formatting for email strings
* Get information from ORCID and API

## Contributing

See [the contributing file](CONTRIBUTING.md)!

PRs accepted.

## License

[MIT © Pranav Mishra](LICENSE)


text:
# Event-Sourcing-with-CQRS-in-Laravel

### What is Event Sourcing

Event sourcing is nothing but a term or architectural pattern. If something or anything happen
(called event) and stored in one place and at a certen time if we could fetch those event form that
particular place is called Event Sourcing.

![es](https://user-images.githubusercontent.com/27927662/34467456-981665a6-ef1c-11e7-9b15-dc949c93ce13.png)

### What is CQRS

CQRS is the sort form of Command Query Responsibility Segregation.
What does it mean? Here Command and Query both are task. Command means occurring any changes and Query
is to fetch data according application demand. Simply Command and Query is read and write. Bertrand Meyer
introduce CQRS to us. CQRS pattern helps software architect to design the application architecture
where reading and writing are separate.
It makes the application more secure and maximize the performance.

![cqrs](https://user-images.githubusercontent.com/27927662/34467460-ba37faaa-ef1c-11e7-86c3-4b6638b6e827.png)

### Why programmer use or do not use Event Sourcing

Event Sourcing isn't something you could use in every application. The most toughest thing of event
sourcing is to understant where to use it. It makes the application traceable and secure. If any how
you loss any data you could retrive from event or something happen unexpected, easily it can be tracked
and solved.
As data reading gets the priority when events are transferd to the query database, it becomes easy and
load less to read the data which makes the application faster and efficient.
Event Sourcing is good for big and complex project where you may need historic event. Using ES in small
or simple CRUD application will just make it complex without giving significant benefits.

### Why programmer use CQRS

It is one of the most intesting design pattern if used properly. It makes read and write independent
which balance server load and keep code clean. When ES requires complex query, CQRS makes it simple.
Programmer implement CQRS also to handle too much database request.

### About the project

I tried to keep the projetc as simple as possible to make it understandable to the beginners.

It's a demo banking system with two user types one is Account Holder and the other one is Manager.

> Account Holder Activity...
	Account Holder will be able to deposit money.
	and
	Will be able to transfer to the another Account Holder's Account.

> Manager's Activity...
	Manager can erase the Account Holder's deposited amount.
	and
	Stop the Account Holder's transaction

Registration is required for both User.

### How i use Event Sourcing and CQRS

	Use of database____
		There are three table in database. users, deposits and event_store.

		> users for Account Holder and Manager both are differentiated by type column.
		> deposits is for the amount the have.
		  And
		> event_stores is used to store the event.

	Account Holder's activity____

		** Data Reading(Query)___

			* Show Amount
				Request goes to show method of Account Controller. Instantiate QueryService initializing
				 Account Holder's email id. And then get the balance.

		** Data Writing(Command)___

			* Deposit

				Account Holder's request will be redirected to the Account Controller.
				To deposit amount there is a deposit method where AccountCommandHandler is called to
				handle the Command(command is event identifier).
				And pass a parameter of AccountDepositCommand where deposit command, account holder's
				email and amount is initialized.

				In AccountCommandHandler Class, event is created in JSON format calling
				CreateDepositeEvent.

				There are two more class is Instantiated one is EventStore and other one is EventHandler.
				EventStore is to store the event in event_stores table with command.
				And EventHandler is to handle the event, where deposit data goes to deposit table.

			* Transfer

				Amount transferring is as same as the deposit,
				Transferring Request goes to transfer method of Account Controller, here Request
				data(Sender, Receiver and amount) is inintialized in AccountTransferCommand and the
				AccountTransferCommand object is passed to AccountTransferCommandHandler.

				In AccountTransferCommandHandler,
					CreateTransferEvent create transfer event.
					EventStore store the created event.
					And then goes to EventHandler.
				In EventHandler transfer successfully executed if the amount is less or equal than
				the sender total amount otherwise the transffer failed.

	Manager activity____

		** Data Reading(Query)___

			* Show Account Deposit
				When the request executed it comes accountsList of Manager Controller, where
				getAccountsList method of AdminQueryService is called.

			* History
				Every event is showed here. History request first comes to history method of Manager
				Class.
				Then goes to getHistory of AdminQueryService.

		** Data Writing(Command)___

			* Stop Transection

				The Request comes from history page. First goes stopTransection method of Manager
				class and create a object of AccountStopCommand initializing sender, receiver and
				amount value and pass this object to AccountStopCommandHandler to create, store and
				handle the event. In EventHandler sender gets the transfer amount and receiver lost
				the amount.

			* Deposit Delete
				To delete deposite delete method of Manager create AccountDeleteCommand object and send
				it to AccountDeleteCommandHandler. And first event created then event Store and at last
				event is handled deleting specific row of deposit table.

![es with cqrs](https://user-images.githubusercontent.com/27927662/34467488-bf3935e0-ef1d-11e7-87d2-41fed6dd7646.png)

### Why i use Event Sourcing and CQRS

	* To track the deposit and transfer of Account Holder.
	* To minimize the complex query like join.
	* To keep code clean.
	* To make it easy to add new feature.


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

### Description

Unrestricted file upload vulnerability in upload.php in the Giulio Ganci Wp Downloads Manager module 0.2 for WordPress allows remote attackers to execute arbitrary code by uploading a file with an executable extension via the upfile parameter, then accessing it via a direct request to the file in wp-content/plugins/downloads-manager/upload/.

### POC

#### Reference
- http://securityreason.com/securityalert/4060
- https://www.exploit-db.com/exploits/6127

#### Github
No PoCs found on GitHub currently.

repository: trickest/cve

gha_language: HTML

repo_name: trickest/cve


text:
![Base16 Logo](https://raw.github.com/chriskempson/base16/master/base16-logo.png)
Base16 provides carefully chosen syntax highlighting and a default set of sixteen colors suitable for a wide range of applications.
Base16 is both a color scheme and a template. To roll your own see [base16-builder](https://github.com/chriskempson/base16-builder).

## Preview
To preview the various base16 themes visit http://chriskempson.github.com/base16 - Preview page courtesy of [tybenz](http://tybenz.com).

![Base16 Default](https://raw.github.com/chriskempson/base16/master/base16-default.png)
Base16's default color scheme.

## Repositories
Check out the individual repositories for screenshots of Base16 in action.

* [Base 16 Builder](https://github.com/chriskempson/base16-builder)
* [vx/ConnectBot](https://github.com/jprjr/base16-connectbot)
* [Chrome DevTools](https://github.com/idleberg/base16-chrome-devtools)
* [Emacs](https://github.com/neil477/base16-emacs)
* [Geany](https://github.com/robloach/base16-geany)
* [Gimp Palette](https://github.com/chriskempson/base16-gimp-palette)
* [Gnome Terminal](https://github.com/chriskempson/base16-gnome-terminal)
* [iTerm2](https://github.com/chriskempson/base16-iterm2)
* [MinTTY](https://github.com/geoffstokes/base16-mintty)
* [Mou](https://github.com/chriskempson/base16-mou)
* [Notepad++](https://github.com/idleberg/base16-notepad-plus-plus)
* [OSX Color Palette](https://github.com/chriskempson/base16-osx-color-palette)
* [PuTTY](https://github.com/benjojo/base-16-putty/)
* [Shell](https://github.com/chriskempson/base16-shell)
* [TextMate & Sublime Text](https://github.com/chriskempson/base16-textmate)
* [Vim](https://github.com/chriskempson/base16-vim)
* [Windows Command Prompt](https://github.com/geoffstokes/base16-windows-command-prompt)
* [Xcode 4] (https://github.com/joedynamite/base16-xcode4)
* [XFCE4 Terminal](https://github.com/chriskempson/base16-xfce4-terminal)
* [Xresources](https://github.com/chriskempson/base16-xresources)
* [Zathura PDF Reader](https://github.com/esn89/base16-zathura)

## Contributing
Please submit any issues and/or pull requests to the appropriate [repository](https://github.com/chriskempson/base16#repositories). No pull requests shall be merged into this repository.

## Template Maintainers
* [chriskempson](https://github.com/chriskempson) - Base 16 Builder, Vim, Shell, iTerm2, TextMate, OSX Color Palette, Xresources, Mou, XFCE4 Terminal, Gimp Palette, Gnome Terminal
* [neil477](https://github.com/neil477) - Emacs
* [robloach](https://github.com/robloach) - Geany
* [geoffstokes](https://github.com/geoffstokes) - Windows Command Prompt, MinTTY
* [atelierbram](htpps://github.com/atelierbram) - Prism

## Projects using Base16
* [c-Tiles16](https://github.com/atelierbram/c-tiles16) Colorscheming with Variables
* [Spacegray](https://github.com/kkga/spacegray) A set of custom UI themes for Sublime Text 2/3


text:
Dan North has fleshed out some of his thoughts on
[CUPID](https://dannorth.net/2022/02/10/cupid-for-joyful-coding/) into a
standalone narrative.  He talks again about how using _properties_ instead of
_principles_ leads to "centered sets" with a goal to move towards.  I've been
using a football analogy lately were there is not just one goal at the center,
but an entire endzone.  Anywhere in endzone is valid, and there are many ways to
get in the endzone.  Specific players specialize in specific paths to the
endzone, and sometimes they lose perspective that other paths can be just as
valid as theirs, depending on context and circumstances.


text:
# Effective english

Blog for learning English course in Effective band

0. `npm i` - install packages
1. `npm start` - start project localy
2. Create new folder (```./content/blog/```) and new md-file inside that folder to create new article
3. `npm deploy` - deploy to Github-pages

If you have problems with lunch this project, you may install globaly *gatsby-cli*: `npm install -g gatsby-cli`, in Linux OS with a *sudo* rights

**GutHub hosting**: [https://evgenyleukhin.github.io/effective-english/]

**Created by**: [https://github.com/gatsbyjs/gatsby-starter-blog]

## Text formating in md-files:

* `# Title1, ## Title2 and so on` - titles
* `Paragraph - simple text` - paragraphs
* `**Italic**` - italic
* `*Bold*` - italic
* `> blockquote` - blockquote
* `- Something, 1. Something` - lists
* `[Link text](http://link-url.com)` - links
* `![Image alt text](./filename.jpg)` - load images in article, image should in the same folder the an article

repository: EvgenyLeukhin/effective-english

repo_name: EvgenyLeukhin/effective-english


text:
[![npm](https://img.shields.io/npm/v/nativescript-azure-cognitiveservices.svg)](https://www.npmjs.com/package/nativescript-azure-cognitiveservices)
[![npm](https://img.shields.io/npm/dt/nativescript-azure-cognitiveservices.svg?label=npm%20downloads)](https://www.npmjs.com/package/nativescript-azure-cognitiveservices)

# nativescript-azure-cognitiveservices
[Azure cognitive services](https://azure.microsoft.com/en-us/services/cognitive-services/) implementation for NativeScript. Both iOS & Android platfroms are supported.

**Features:**

* Speech to Text
* Text to Speech
* WAV recorder

**Note**: When you will use this service that time UI will keep block until any result will come. I'll recommend to use [NativeScript Worker Loader](https://github.com/NativeScript/worker-loader) to run the service in background

## Installation

```javascript
tns plugin add nativescript-azure-cognitiveservices
```

## Usage (Please check demo project for details)

**Import**

JavaScript:
```javascript
var azure = require("nativescript-azure-cognitiveservices");
var azureService = new azure.AzureCognitiveservices("API_KEY", "Region");
```

TS:
```javascript
import { AzureCognitiveservices, SpeechSynthesisResult, SpeechToTextResult } from "nativescript-azure-cognitiveservices";

constructor() {
    this.azureService = new AzureCognitiveservices("API_KEY", "Region");
}
```

**Functions**
```javascript
speechSynthesis(contents: any, voiceName?: string): any;
speechToTextRecognizeOnce(audioFile?: string, recognitionLanguage?: string): any;
startContinuousRecognition(recognitionLanguage?: string): any;
stopContinuousRecognition(): void;
startRecorder(fileName?: string): void;
stopRecorder(): any;
audioDataSaveAsMP3(audioData: any, fileName?: string): Promise<string>;
```

**Require Permission:**

Android:
```javascript
<uses-permission android:name="android.permission.RECORD_AUDIO" />
```

iOS:
```javascript
<key>NSMicrophoneUsageDescription</key>
<string>Recording Practice Sessions</string>
```


text:
# v0.4.0 Whoa, What a Release!

**App Version: v0.4.0**

**Database Version: v0.4.0**

## Breaking Changes

!!! error "Breaking Changes"

    #### Database
    A new database will be created. You must export your data and then import it after upgrading.

    #### Site Settings
    With the addition of group settings and a re-write of the database layer of the application backend, there is no migration path for your current site settings. Webhooks Settings, Meal Plan Categories are now managed by groups. Site settings, mainly homepage settings, are now site specific and managed by administrators. When upgrading be sure to uncheck the settings when importing your old data.

    #### ENV Variables
    Names have been changed to be more consistent with industry standards. See the [Installation Page](/mealie/getting-started/install/) for new parameters.

## Bug Fixes
- Fixed Search Results Limited to 100 - #198
- Fixed recipes from marmiton.org not fully scrapped  - #196
- Fixed Unable to get a page to load - #194
- Fixed Recipe's from Epicurious don't upload. - #193
- Fixed Edited blank recipe in meal plan is not saved - #184
- Fixed Create a new meal plan allows selection of an end date that is prior to the start date - #183
- Fixed Original URL not saved to imported recipe in 0.3.0-dev - #183
- Fixed "IndexError: list index out of range" when viewing shopping list for meal plan containing days without a recipe selected - #178

## Features and Improvements

### General
  - Documentation Rewrite
  - [New Demo Site!](https://mealie-demo.hay-kot.dev/)
  - New Documentation
    - Landing Page
    - Custom Caddy Configuration
    - User Management
    - Introduction
  - Updated Documentation
    - Everything!
  - The API Reference is now better embedded inside of the docs
  - New default external port in documentation (Port 9000 -> 9925). This is only the port exposed by the host to the docker image. It doesn't change any existing functionality.

### User Authentication
  - Authentication! Tons of stuff went into creating a flexible authentication platform for a lot of different use cases. Review the documentation for more information on how to use the authentication, and how everything works together. More complex management of recipes and user restrictions are in the works, but this is a great start! Some key features include
    - Sign Up Links
    - Admin and User Roles
    - Password Change
    - Group Management
    - Create/Edit/Delete Restrictions

### Custom Pages
  - You can now create custom pages that are displayed on the homepage sidebar to organize categories of recipes into pages. For example, if you have several categories that encompass "Entrée" you can group all those categories together under the "Entrée" page. See [Building Pages](/mealie/site-administration/building-pages/) for more information.
!!! tip
    Note that this replaces the behavior of automatically adding categories to the sidebar.

### UI Improvements
  - Completed Redesign of the Admin Panel
    - Profile Pages
    - Side Panel Menu
  - Improved UI for Recipe Search
  - Language selector is now displayed on all pages and does not require an account

### Recipe Data
  - Recipe Database Refactoring. Tons of new information is now stored for recipes in the database. Not all is accessible via the UI, but it's coming.
    - Nutrition Information
      - calories
      - fatContent
      - fiberContent
      - proteinContent
      - sodiumContent
      - sugarContent
    - recipeCuisine has been added
    - "categories" has been migrated to "recipeCategory" to adhere closer to the standard schema
    - "tool" - a list of tools used for the recipe

### Behind the Scenes
  - Removed CDN dependencies
  - Database Model Refactoring
  - Import/Export refactoring
  - File/Folder Name Refactoring
  - Development is now easier with a makefile
  - Mealie is now a proper package using poetry
  - Test refactoring
  - Test Coverage 83% up from 75%!

repository: agneevX/mealie

repo_name: agneevX/mealie


text:
---
author: kubu4
comments: true
date: 2014-03-28 20:14:40+00:00
layout: post
slug: dna-isolation-c-gigas-female-gonads-from-frozen
title: DNA Isolation - C.gigas Female Gonads (from frozen)
wordpress_id: 164
author:
  - kubu4
categories:
  - Lineage-specific DNA methylation patterns in developing oysters
tags:
  - Crassostrea gigas
  - DNA Isolation
  - DNA Quantification
  - DNeasy
  - female
  - gonad
  - NanoDrop1000
  - Pacific oyster
---

Isolated gDNA from Claire's "Female DNA" (from 05/16/2013) using the Qiagen Blood & Tissue DNeasy Kit according to the manufacturer's protocol, with the following changes:

  1. Incubated sample in Buffer ATL + Proteinase K @ 56C for 3hrs. Vortexed once each hour.

  2. Eluted with 100uL of Buffer AE.

Results:

![](https://eagle.fish.washington.edu/Arabidopsis/20140328%20-%20Claire%20gigas%20CgF%20gDNA%20ODs.JPG)

Excellent yield and quality is good, although both the 260/280 and 260/230 ratios are on the high side. However, these high values could be an artifact of the high sample concentration (this is a common "issue" with the NanoDrop).

repository: RobertsLab/sams-notebook

extension: markdown

gha_language: Shell

repo_name: RobertsLab/sams-notebook


text:
# Global and Static Variables

Sure you have been in the situation where you declared the same variable in each and every script over and over again.
"Why is there no way to make them available in every script?" Is what went through your head at such times.

Be relieved now for there has been added a means of declaring and accessing global and scriptbound (static) values!
They cannot be changed, though.

## Difference between statics and globals
Both, statics and globals are scriptbound and instantiated before the script is executed.
Both cannot be changed.
The difference is how they are called:
Globals can be called from everywhere simply by their name unless you already have a local variable that has the same name.
Statics on the other hand, need to use the [cross-script reference](/AdvancedFunctions/Cross-Script_Reference/) to be accessed.

Globals are created using the `global` keyword.
Statics are created using the `static` keyword.

Aside from that, they are identical!

## Declaring a global value
Declaring a global value is as simple as declaring a local value:

```zenscript
import crafttweaker.item.IItemStack;

global myGlobalValue as IItemStack = <minecraft:dirt>;
static myStaticValue as IItemStack = <minecraft:sand>;
```

Okay, let's break it down, shall we?

1. `global` keyword that indicates the declaration of a global value
2. `myGlobalValue` the name of the value
3. `as IItemStack` the type of the value (It is recommended to [import](/AdvancedFunctions/Import/) the types before casting the variable)
4. `= <minecraft:dirt>;` value initialization. As global values are final, you need to initialize them whilst declaring them!

## Words of advice

- You can only access globals that have already been declared. Use the [Priority Preprocessor](/AdvancedFunctions/Preprocessors/PriorityPreprocessor/) to make sure the scripts in which global are declared  are executed first.
- Globals cannot be declared in scripts that are inside subfolders! It will compile but you will be left with a huge FieldNotFound Exception.
- While it is technically possible to omit the `as` part, it is recommended leaving it in, as the IAny interface is not fully functional yet. Also, it makes your declaration more clear for people reading/debugging your script!
- Local variables/values CAN overshadow global variables. The script will always search the innermost scope for variables and go outwards until it hits global when searching for keywords!

repository: kindlich/CraftTweaker-Documentation

repo_name: kindlich/CraftTweaker-Documentation


text:
[![Join the chat at https://gitter.im/bebraw/reactabular](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/bebraw/reactabular?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) [![build status](https://secure.travis-ci.org/bebraw/reactabular.png)](http://travis-ci.org/bebraw/reactabular) [![bitHound Score](https://www.bithound.io/github/bebraw/reactabular/badges/score.svg)](https://www.bithound.io/github/bebraw/reactabular) [![Dependency Status](https://david-dm.org/bebraw/reactabular.svg)](https://david-dm.org/bebraw/reactabular)
# Reactabular - Spectacular tables for React.js

Reactabular has been designed to make it easier to build tables on top of React.js. The core has been kept simple while allowing you to extend it as needed. You can customize rendering on cell level and adjust the way data is sorted. This way you can implement basic functionalities such as search, pagination, sorting, inline editing and so on.

The library can work with either fixed data loaded once or you can hook it into a backend through a method of your choosing. For instance it works well with various Flux approaches. The table simply consumes the data from store which you then adjust using various actions.

The chosen approach means it might take more code to achieve certain goals. This gives you a degree of freedom while keeping the core easier to maintain.

## Documentation

See `docs/`.

## Development

```bash
npm install
npm start
open http://localhost:8080
```

Now edit `demos/app.js`.

Your changes will appear without reloading the browser like in [this video](http://vimeo.com/100010922).

## Contributors

* [Brian Chang](https://github.com/eviltoylet) - Fixed README formatting examples. Improved `column.cell` architecture. Helped to improve and design `cell` API.
* [Antoine Verger](https://github.com/antoineverger) - Allow editor text inputs to be erased correctly
* [Daan Nijkamp](https://github.com/daannijkamp) - Fixed README search example.
* [Utku Demir](https://github.com/utdemir) - Helped to ideate row API.
* [Andrea de la Isla](https://github.com/nuragic) - Made search algorithm stable and allowed header to be customized.
* [cameron](https://github.com/cameront) - Helped to render nested properties through cells.
* [Igor Kaplounenko](https://github.com/megawidget) - Allowed `rowKey` to be set.
* [BJR Matos](https://github.com/bjrmatos) - Restored Node 0.10 support.
* [Sitian Liu](https://github.com/goldensunliu) - Fixed header definition documentation.

## Acknowledgments

Based on [react-hot-boilerplate](https://github.com/gaearon/react-hot-boilerplate) (MIT) by Dan Abramov.

## License

MIT. See LICENSE for details.

repository: vicall/reactabular

repo_name: vicall/reactabular


text:
## Carbon ![Unmaintained](https://img.shields.io/badge/status-unmaintained-red.svg)
Originally developed for ACM contests but can be used in any other sphere of activity where program need to be compiled, executed and checked for the right answer to specified input.

### Requirements
* colorlog
* psutil
* Linux based OS (tested on Ubuntu 14.04)

### Security
For running untrusted code Carbon needs to be run by non-root user (this will not give permissions to program and engine will care about time and memory limits).

### Installation
```bash
python setup.py install
```

### Usage
```python
import logging
from carbon.engine import Engine
from carbon.langs_config import py

# init engine with minimal logging level of DEBUG
en = Engine(logging.DEBUG)

# let's test some code for implementing sum of two integers
# and autoremove this file after testing
en.test_program('code.py', py, '4 5', '9', True)
```

### ToDo
* Add length limit to STDOUT of program
* Move from dicts to config classes

repository: laplab/carbon

repo_name: laplab/carbon


text:
<!-- START doctoc generated TOC please keep comment here to allow auto update -->
<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
**Table of Contents**  *generated with [DocToc](https://github.com/thlorenz/doctoc)*

- [v1alpha6 compared to v1alpha7](#v1alpha6-compared-to-v1alpha7)
  - [Migration](#migration)
  - [API Changes](#api-changes)
    - [`OpenStackMachine`](#openstackmachine)
      - [⚠ Removal of networks](#-removal-of-networks)
      - [Removal of subnet](#removal-of-subnet)
      - [Change to securityGroups](#change-to-securitygroups)
      - [Changes to ports](#changes-to-ports)
        - [Change to securityGroupFilters](#change-to-securitygroupfilters)
        - [Removal of securityGroups](#removal-of-securitygroups)
        - [Removal of tenantId and projectId](#removal-of-tenantid-and-projectid)
        - [Change to profile](#change-to-profile)
    - [`OpenStackCluster`](#openstackcluster)
      - [Change to externalRouterIPs.subnet](#change-to-externalrouteripssubnet)

<!-- END doctoc generated TOC please keep comment here to allow auto update -->

# v1alpha6 compared to v1alpha7

> ⚠ v1alpha7 has not been released yet.

## Migration

All users are encouraged to migrate their usage of the CAPO CRDs from older versions to `v1alpha6`. This includes yaml files and source code. As CAPO implements automatic conversions between the CRD versions, this migration can happen after installing the new CAPO release.

## API Changes

This only documents backwards incompatible changes. Fields that were added to v1alpha6 are not listed here.

### `OpenStackMachine`

#### ⚠ Removal of networks

This is a major breaking change between v1alpha6 and v1alpha7 which in certain circumstances **may require manual action before upgrading to v0.8**.

v1alpha6 allowed network attachments to an OpenStackMachine to be specified as either Networks or Ports. In v1alpha7, Networks are removed. Network attachments may only be specified as ports.

In most cases Networks will be automatically converted to equivalent Ports on upgrade. However, this is not supported in the case where a Network specifies a network or subnet filter which returns more than one OpenStack resource. In this case it is important to rewrite any affected OpenStackMachineTemplates and wait for any consequent rollout to complete prior to updating to version 0.8.

Your configuration is affected if it contains any Network or Subnet filter which returns multiple resources. In a v1alpha6 Network definition this resulted in the creation of multiple ports: one for each returned result. In a Port definition, filters may only return a single resource and throw an error if multiple resources are returned.

For example, take this example OpenStackMachineTemplate specification:

```yaml
apiVersion: infrastructure.cluster.x-k8s.io/v1alpha6
kind: OpenStackMachineTemplate
metadata:
  name: ${CLUSTER_NAME}-md-0
spec:
  template:
    spec:
      ..
      networks:
      - filter:
          tags: tag-matches-multiple-networks
        subnets:
        - filter:
            tags: tag-matches-multiple-subnets
```

In this configuration both the network and subnet filters match multiple resources. In v0.8 this will be automatically converted to:

```yaml
apiVersion: infrastructure.cluster.x-k8s.io/v1alpha7
kind: OpenStackMachineTemplate
metadata:
  name: ${CLUSTER_NAME}-md-0
spec:
  template:
    spec:
      ..
      ports:
      - network:
          tags: tag-matches-multiple-networks
        fixedIPs:
        - subnet:
            tags: tag-matches-multiple-subnets
```

However, this will cause an error when reconciled by the machine controller, because in a port:
* a network filter may only return a single network
* a subnet filter may only return a single subnet

Instead it needs to be rewritten prior to upgrading to version 0.8. It can be rewritten as either ports or networks, as long as each results in the creation of only a single port. For example, rewriting without converting to ports might give:

```yaml
apiVersion: infrastructure.cluster.x-k8s.io/v1alpha6
kind: OpenStackMachineTemplate
metadata:
  name: ${CLUSTER_NAME}-md-0
spec:
  template:
    spec:
      ..
      networks:
      - filter:
          name: network-a
        subnets:
        - filter:
            name: subnet-a
      - filter:
          name: network-b
        subnets:
        - filter:
            name: subnet-b
```

This will be safely converted to use ports when upgrading to version 0.8.

To reiterate: it is not sufficient to leave your templates at v1alpha6 in this case, as it will still result in failure to reconcile in the machine controller. This change must be made prior to updating to version 0.8.

#### Removal of subnet

The OpenStackMachine spec previously contained a `subnet` field which could used
to set the `accessIPv4` field on Nova servers. This feature was not widely
used, difficult to use, and could not be extended to support IPv6. It is
removed without replacement.

#### Change to securityGroups

`securityGroups` has been simplified by the removal of a separate filter parameter. It was previously:
```yaml
securityGroups:
  uuid: ...
  name: ...
  filter:
    description: ...
    tags: ...
    ...
```
It becomes:
```yaml
securityGroups:
  id: ...
  name: ...
  description: ...
  tags: ...
  ...
```

Note that in this change, the `uuid` field has become `id`. So:
```yaml
securityGroups:
- uuid: 4ea83db6-2760-41a9-b25a-e625a1161ed0
```
becomes:
```yaml
securityGroups:
- id: 4ea83db6-2760-41a9-b25a-e625a1161ed0
```

The `limit`, `marker`, `sortKey`, `sortDir`, fields have been removed without replacement. They did not serve any purpose in this context.

The `tenantId` parameter has been removed. Use `projectId` instead.

#### Changes to ports

##### Change to securityGroupFilters

The same change is made to `securityGroupFilters` in `ports` as is [made to `securityGroups` in the machine spec](#change-to-securitygroups).

##### Removal of securityGroups

The Port field of the OpenStackMachine spec previously contained both `securityGroups` and `securityGroupFilters`.
As `securityGroups` can easily be replaced with `securityGroupFilters`, that can express the same and more, `securityGroups` has now been removed.
CAPO can automatically convert `securityGroups` to `securityGroupFilters` when upgrading.

Here is an example of how to use `securityGroupFilters` to replace `securityGroups`:

```yaml
# securityGroups are available in v1alpha6
securityGroups:
- 60ed83f1-8886-41c6-a1c7-fcfbdf3f04c2
- 0ddd14d9-5c33-4734-b7d0-ac4fdf35c2d9
- 4a131d3e-9939-4a6b-adea-788a2e89fcd8
# securityGroupFilters are available in both v1alpha6 and v1alpha7
securityGroupFilters:
- id: 60ed83f1-8886-41c6-a1c7-fcfbdf3f04c2
- id: 0ddd14d9-5c33-4734-b7d0-ac4fdf35c2d9
- id: 4a131d3e-9939-4a6b-adea-788a2e89fcd8
```

##### Removal of tenantId and projectId

These are removed without replacement. They required admin permission to set, which CAPO does not have by default, and served no purpose.

##### Change to profile

We previously allowed to use the Neutron `binding:profile` via `ports.profile` but this API is not declared as stable from the [Neutron API description](https://docs.openstack.org/api-ref/network/v2/index.html?expanded=create-port-detail#create-port).

Instead, we now explicitly support two use cases:
* OVS Hardware Offload
* Trusted Virtual Functions (VF)

Note that the conversion is lossy, we only support the two use cases above so if anyone was relying on anything other than
the supported behaviour, it will be lost.

Here is an example on how to use `ports.profile` for enabling OVS Hardware Offload:

```yaml
profile:
  OVSHWOffload: true
```

Here is an example on how to use `ports.bindingProfile` for enabling "trusted-mode" to the VF:

```yaml
profile:
  TrustedVF: true
```

### `OpenStackCluster`

#### Change to externalRouterIPs.subnet

The `uuid` field is renamed to `id`, and all fields from `filter` are moved directly into the `subnet`.

```yaml
externalRouterIPs:
- subnet:
    uuid: f23bf9c1-8c66-4383-b474-ada1d1960149
- subnet:
    filter:
      name: my-subnet
```
becomes:
```yaml
externalRouterIPs:
- subnet:
    id: f23bf9c1-8c66-4383-b474-ada1d1960149
- subnet:
    name: my-subnet
```

#### status.router and status.apiServerLoadBalancer moved out of status.network

```yaml
status:
  network:
    id: 756f59c0-2a9b-495e-9bb1-951762523d2d
    name: my-cluster-network
    ...
    router:
      id: dd0b23a7-e785-4061-93c5-464843e8cc39
      name: my-cluster-router
      ...
    apiServerLoadBalancer:
      id: 660d628e-cbcb-4c10-9910-e2e6493643c7
      name: my-api-server-loadbalancer
      ...
```
becomes:
```yaml
status:
  network:
    id: 756f59c0-2a9b-495e-9bb1-951762523d2d
    name: my-cluster-network
    ...
  router:
    id: dd0b23a7-e785-4061-93c5-464843e8cc39
    name: my-cluster-router
    ...
  apiServerLoadBalancer:
    id: 660d628e-cbcb-4c10-9910-e2e6493643c7
    name: my-api-server-loadbalancer
    ...
```

#### status.network.subnet becomes status.network.subnets

```yaml
status:
  network:
    id: 756f59c0-2a9b-495e-9bb1-951762523d2d
    name: my-cluster-network
    subnet:
      id: 0e0c3d69-040a-4b51-a3f5-0f5d010b36f4
      name: my-cluster-subnet
      cidr: <IP_ADDRESS>/24
```
becomes
```yaml
  network:
    id: 756f59c0-2a9b-495e-9bb1-951762523d2d
    name: my-cluster-network
    subnets:
    - id: 0e0c3d69-040a-4b51-a3f5-0f5d010b36f4
      name: my-cluster-subnet
      cidr: <IP_ADDRESS>/24
```

Nothing will currently create more than a single subnet, but there may be multiple subnets in the future. Similarly, code should no longer assume that the CIDR is an IPv4 CIDR, although nothing will currently create anything other than an IPv4 CIDR.

gha_language: Go


text:
# Equalizer

## Setting up the project

### 1. Clone the repo
```
git clone https://github.com/shreyasseshadri/Equalizer.git

```
### 2. Install the required dependencies

#### NOTE : The paths specified in the commands are relative paths from the root folder

Client Dependencies.
```
cd Equalizer
npm install
```
Server dependencies

```
cd Equalizer/EqualizerServer
npm install
```

### 3. Running server and client

Server

```
cd EqualizerServer

npm start
```

Client
```
cd Equalizer
npm start

```

This commands starts the clients at two locations

```
localhost:9966
localhost:9966/#init
```
The client with location # as init is the client to start the exchange of network ID

## Server Usage

Server currently has three routes
- `/exchange` - A web socket connection that connects with the first client  mentioned above, responsible for exchange of network IDs.
-  `/exchange/init` - A web socket that connects with the second client mentioned above, responsible for exchange of network IDs.
- `/translate` - A route for POST requests for translation.

#### Usage of /translate route

Translate route listens for POST requests, and is responsible for translation
It requires two paramaters `<string to be translated>` and `<Language to which it must translate>` in ISO format.

Sample fetch request for translate
```
fetch('http://localhost:3000/translate', {
        method: 'POST',
        mode:'cors',
        headers: {
            'Accept': 'application/json',
            'Content-Type': 'application/json',
        },
        body: JSON.stringify({
            text:'धन्यवाद',
            to:'en', //ISO format for english
        }),
        })
        .then(function (response) {
            return response.json();
        })
        .then(json => {
            // Response JSON from server
            console.log(json);
            })
            .catch(function (error) {
                throw error;
    });

```
Response from the server contains
- Translated text
- Identified language of the text sent by the client

```
{
    result: "Thank you",
    language: "hi" //ISO format for hindi
}
```

repository: shreyasseshadri/Equalizer

repo_name: shreyasseshadri/Equalizer


text:
# 822. Card Flipping Game

Difficulty: Medium

https://leetcode.com/problems/card-flipping-game/

On a table are N cards, with a positive integer printed on the front and back of each card (possibly different).

We flip any number of cards, and after we choose one card.

If the number X on the back of the chosen card is not on the front of any card, then this number X is good.

What is the smallest number that is good?  If no number is good, output 0.

Here, fronts[i] and backs[i] represent the number on the front and back of card i.

A flip swaps the front and back numbers, so the value on the front is now on the back and vice versa.

**Example:**
```
Input: fronts = [1,2,4,4,7], backs = [1,3,4,1,3]
Output: 2
Explanation: If we flip the second card, the fronts are [1,3,4,4,7] and the backs are [1,2,4,1,3].
We choose the second card, which has number 2 on the back, and it isn't on the front of any card, so 2 is good.
```

**Note:**

1. 1 <= fronts.length == backs.length <= 1000.
2. 1 <= fronts[i] <= 2000.
3. 1 <= backs[i] <= 2000.

repository: jiadaizhao/LeetCode

repo_name: jiadaizhao/LeetCode


text:
# DAT-P: Data Analysis in Python

The file "prepare_analyze_data.py" shows some frequently executed statistical analyses on data collected in speech quality assessment studies.
The file "csnoisy.results50.csv" represents the speech quality ratings collected from the crowdsourcing listeners, whereas "Lab.sav" are the quality ratings from the listeners in the Laboratory that executed the listening test in an optimal environment.
This data correspond to the "Group 1" of the study described in [[1]](#1).

## References

[1]
R. Zequeira Jiménez, B. Naderi, and S. Möller, "Effect of Environmental Noise in Speech Quality Assessment Studies using Crowdsourcing," in 2020 Twelfth International Conference on Quality of Multimedia Experience (QoMEX), 2020, pp. 1–6. [DOI: https://doi.org/10.1109/QoMEX48832.2020.9123144]

repository: zequeira/DAT-P

repo_name: zequeira/DAT-P


text:
![Logo](screenshot/Logo3.png)

# Mobile Native Code Plugin for Unreal Engine 4
When developing a mobile application based on Unreal engine 4, you often need to get access to functionality that is not available in C++/Blueprint. For example:
* Get absolute paths to temporary folders to save your own files
* Read information from sensors (Accelerometer, Barometer, etc.)
* Get information about the phone
* Interact with other apps
* Connect different advertising and analytics services (Facebook, Firebase, Admob)

**Mobile Native Code Plugin** - Serves as the basis for the native mobile plugin in Unreal Engine 4 for Android and iOS platforms. It provides a convenient call to native Java code(JNI) and Objective-C, as well as examples of connecting static and dynamic libraries to the build system. Add it to your project and start expanding it with your features.

# Features
![Java](screenshot/CallJava4.png)

* Requires Unreal Engine 4.21 or higher.
* Builds on ndk-14 and ndk-21 for Android
* Calling native Java code with a single function from C++
* Examples of functions for interacting with native code
Located on the path:
> **Blueprint\C++** - MobileNativeCode\Source\MobileNativeCode\Private\MobileNativeCodeBlueprint.cpp

 > **Android** - MobileNativeCode\Source\MobileNativeCode\Private\Android\Java\

> **IOS** - MobileNativeCode\Source\MobileNativeCode\Private\IOS\ObjC\

* Visual Studio/(If IOS - Xcode) is needed to build the plugin
* Tested on 2 versions of Unreal Engine 4 (4.24/4.25) and 3 phones
* The entire code is divided into blocks for easier understanding

> // #~~~~~~~~~ begin 1 ~~~~~~~~~~

> // ~~~~~~~~~~~ end 1 ~~~~~~~~~~

# Setup

1) Copy MobileNativeCode to the Plugins folder located in the main path of your project (if not, create it).

![PathPlugin](screenshot/PathPlugin2.png)

2) Enable MobileNativeCode in Edit->Plugins->Installed->Mobile->MobileNativeCode. Restart the editor.

![EnablePlugin](screenshot/EnablePlugin1.png)

3) in the LevelBlueprint, create a diagram.

![LevelBlueprint](screenshot/LevelBlueprint2.png)

4) **Run on your mobile device.**

5) Go to *"MobileNativeCode\Source\MobileNativeCode\Private\MobileNativeCodeBlueprint.cpp"* to find out how these functions work

# Testing

* *Unreal Engine 4.24* - **Honor Play** - *OpenGL ES2* - *armeabi-v7a* - **ndk-r14b**
 and
* *Unreal Engine 4.25* - **Honor Play** - *OpenGL ES3.1* - *arm64-v8a* - **ndk-r21b**

![HonorPlay](screenshot/HonorPlay_2.png)

* *Unreal Engine 4.25* - **iPhone 7** - *Xcode 12.4* - *macOS BigSur 10.16.1*

![iPhone7](screenshot/iPhone7_2.png)

# Additional information

## for Android

* Go to *MobileNativeCode\Source\MobileNativeCode\Private* and open *MobileNativeCodeBlueprint.cpp*.
This file demonstrates 5 functions for calling Java code.

* **(IMPORTANT!)** When adding a new Java class or changing the current one, delete the **Intermediate** folder in your project folder.

To call your own Java class:

* Add your *Java* class to the folder: *MobileNativeCode\Source\MobileNativeCode\Private\Android\Java*

* Change the value of *package* at: **com.Plugins.MobileNativeCode**

* before the class and functions, add ***@Keep***

* Java code is called using **AndroidUtils::CallJavaCode...**
 This function has two overloads for **static** and **local** Java functions:

> **AndroidUtils::CallJavaCode< *ReturnType* >("com/Plugins/MobileNativeCode/*YourClass*", "*YourFunction*", "", false, arg1, arg2, arg3)**
>* *ReturnType* - is specified depending on the return type. For example *FString* or *TArray< float >*
>* *1 argument* - is package+the name of your class
>* *2 argument* - the name of your function
>* *3 argument* - Set your own signature instead of an automatic one (send a blank one if you need an automatic one).
> In most cases, this argument will be empty
>* *4 argument* - indicates whether to pass the *Java main Activity* of this session.
> If you want to pass an Activity, it should be specified first in the list of arguments of your Java function
>*  Further, the number of arguments can be passed as many as you want, depending on what your function accepts.

> **AndroidUtils::CallJavaCode< *ReturnType* >(*JavaObjectClass*, "*YourFunction*", "", arg1, arg2, arg3)**
>* *ReturnType* - is specified depending on the return type. For example *FString* or *TArray< float >*
>* *1 argument* - the type of *jobject* that you want to call the local function from
>* *2 argument* - the name of your function
>* *3 argument* - Set your own signature instead of an automatic one (send a blank one if you need an automatic one).
> For example, if the function does not accept any parameters and returns the type of the Bundle class, you should specify **"()Landroid/os/Bundle;"**
>*  Further, the number of arguments can be passed as many as you want, depending on what your function accepts.

* OverrideSignature is specified so that JNI can find the desired function among all java files. Most of the standard types have been added to the plugin and therefore the 3rd function argument can be left empty. For some complex types (for example Bundle) you need to install it.

* To define *Signature* for complex types, you need to add your class to *"MobileNativeCode\Source\MobileNativeCode\ Private\Android\Java\"* and build your Android project. After a successful build, in your project folder navigate to: *"Intermediate\Android\ % ARCH% \gradle\app\build\intermediates\javac\debug\classes\com\Plugins\MobileNativeCode"*
you will see files with ***.class** type. You need to add the path of your **jdk/bin** to the system variables in **PATH**, then you need to open *PowerShell* or *Cmd* in this folder and enter the command **"javap -s YourJavaClass"**. After that, a list of all your functions will appear, our *Signature* will be in the descriptor field.
![SignatureJava](screenshot/Javap_Android.png)

* The ***UMobileNativeCodeBlueprint::ExampleMyJavaObject*** function shows an example of working with local Java objects. In order to assign any Java class to your jobject, you need to return it from a static variable (for example, *return new Bundle ();*) and then call the functions of this jobject, as in Java:
![JavaBundle](screenshot/JavaBundle_Android.png)

* Asynchronous Java invocation occurs through dispatchers UE4 - Java code calls a C++ function, which in turn activates it.

## For iOS

* The Objective-C language can be written in **. cpp* files, but it is better to use **. mm* file

* For some code, you need the key and the resolution (or another Description). The entire list can be seen at the links:
[Description Apple](https://developer.apple.com/documentation/bundleresources/information_property_list/protected_resources),
[Key Apple](https://developer.apple.com/library/archive/documentation/General/Reference/InfoPlistKeyReference/Articles/iPhoneOSKeys.html#//apple_ref/doc/uid/TP40009252-SW3)

* These permissions can be added in Unreal engine 4 itself in the IOS section, but I suggest using the file *MobileNativeCode_UPL_iOS.xml* by path *MobileNativeCode\Source\MobileNativeCode*
In the commented lines, there is an example of how information is added to the Info.plist

* You can see the list of connected public libraries in the file *MobileNativeCode\Source\MobileNativeCode\MobileNativeCode.Build.cs*
![build](screenshot/IOS_framework2.png)
If you don't have the Framework you need, add it yourself by simply continuing the list.
[Learn more about the IOS Framework](https://developer.apple.com/documentation/technologies)

* Also **MobileNativeCode.Build.cs** shows examples of connecting libraries **.framework and* **.bundle* in **.ipa* file

To call Objective-C code

* Add your *Objective-C* class to the *MobileNativeCode\Source\MobileNativeCode\Private\IOS\ObjC* folder

* Connect it to *MobileNativeCode\Source\MobileNativeCode\Private\MobileNativeCodeBlueprint.cpp*

repository: thangduo/PluginMobileNativeCode

repo_name: thangduo/PluginMobileNativeCode


text:
# Volvaria parvula var. biloba Massee, 1893 VARIETY

#### Status
SYNONYM

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Brit. Fung. -Fl. 2: 296 (1893)

#### Original name
Volvaria parvula var. biloba Massee, 1893

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Basidiomycota/Agaricomycetes/Agaricales/Pluteaceae/Volvariella/Volvariella hypopithys/ Syn. Volvaria parvula biloba/README.md

repo_name: mdoering/backbone


text:
# CSSLint for VSCode

My first draft at an extension for [VSCode](http://code.visualstudio.com). This is *really* rough and does not support .cslintrc yet. Be gentle.

Note: Be sure to disable VSCode's internal CSS linting by adding:

    "css.validate": false

to your preferences.

# History
April 6, 2018 - again: Everything should be working now - HUGE thanks to @mseiller025 for helping me get things running.

April 6, 2018: Well, I don't even know what to say. I did some changes, things broke, I have no idea what's wrong, and frankly, I never want to build a VSC extension again. Hopefully this version works better.

April 2, 2018: Two PRs from @mseiler025. One is cleanup, one adds a 'clear issues on document close setting'.

June 12, 2017: First, took in a PR from @coliff that added an icon (thanks!). I then did
a bunch of cleanup while I was trying to get the darn thing running again on my laptop.

January 18, 2017: Updated CSSLint

repository: cfjedimaster/vscode-csslint

gha_language: TypeScript

repo_name: cfjedimaster/vscode-csslint


text:
# Geocoading
===============================================================================

## Setting up development environment

The development environment can be setup either like a pythonista
with the usual python module setup, or like a docker user.

### The pythonista way

Ensure that you have an updated version of pip

```shell
pip --version
```
Should atleast be 1.5.4

If pip version is less than 1.5.4 upgrade it
```
pip install -U pip
```

This will install latest pip

Ensure that you are in virtualenv
if not install virtual env
```
sudo pip install virtualenv
```
This will make install all dependencies to the virtualenv
not on your root

From the module folder install the dependencies. This also installs
the module itself in a very pythonic way.

```
pip install -r requirements.txt
```
## NOTE
Make Sure you had python3
export the configuration file after setup
```
export GMAPS_API_KEY=<API KEY>
```

Before begining you need to migrate tables

Perform migration by
```
python manage.py makemigrations
python manage.py migrate
```

and then create a superuser as no user is currently present in the database and apis require authentication(i.e username and password)

```
Python manage.py createsuperuser
```

Run app by
```
python manage.py runserver
```

Sample excel file

![](https://github.com/hriks/geocoding/blob/master/media/Sample.png)

repository: hriks/geocoding

gha_language: Python

repo_name: hriks/geocoding