text:
### Hey there

Hi, I'm Darshan Chobarkar, a passionate self-taught Full Stack web developer and a freelance software engineer from India. My passion for software lies with dreaming up ideas and making them come true with elegant interfaces. I take great care in the experience, architecture, and code quality of the things I build.

I am also an open-source enthusiast and maintainer. I learned a lot from the open-source community and I love how collaboration and knowledge sharing happened through open-source.

- 💬 Ask me about anything, I am happy to help

- 📫 How to reach me: [@dchobarkar](https://www.linkedin.com/in/dchobarkar/)
- 📫 How to reach me: [@barbatos__08](https://twitter.com/barbatos__08)
- 📫 How to reach me: [@upwork](https://www.upwork.com/freelancers/~01b8baac4280f61338)

## 🔨 Languages and Tools:

## 📈 My GitHub Stats

[![Darshan's GitHub stats](https://github-readme-stats.vercel.app/api?username=dchobarkar&count_private=true&show_icons=true&theme=dark)]()
[![Top Langs](https://github-readme-stats.vercel.app/api/top-langs/?username=dchobarkar&layout=compact&theme=dark)](https://github.com/dchobarkar/github-readme-stats)
[![GitHub Streak](https://streak-stats.demolab.com/?user=dchobarkar&theme=highcontrast)](https://git.io/streak-stats)

_NOTE: Top languages does not indicate my skill level or something like that, it's a github metric of which languages i have the most code on github_

repository: dchobarkar/dchobarkar

repo_name: dchobarkar/dchobarkar


text:
# EasyMask

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

## Example

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

## Requirements

## Installation

EasyMask is available through [CocoaPods](https://cocoapods.org). To install
it, simply add the following line to your Podfile:

```ruby
pod 'EasyMask'
```

## Authors

MarcioFPaludo<EMAIL_ADDRESS>Striker901<EMAIL_ADDRESS>
## License

EasyMask is available under the MIT license. See the LICENSE file for more info.

license: MIT

repository: MarcioFPaludo/EasyMask

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: MarcioFPaludo/EasyMask


text:
A daily advisory saying which government edicts you should not obey to protect your life and other's lives.

For example, there must be Democrats in Jacksonville who do not know going to the beach is not safe.

Tell them. Save lives.

Each time I think the Dems are establishing a persistent online channel via social media, e.g. Howard Dean in 2004, Obama in 2008 and 2012, the Clinton campaign in 2016, Bloomberg this year, even Warren, as soon as the campaign is over the freaking channel closes.

That channel should NEVER close.

Not only is it bad marketing, it's also dangerous policy. Remember Dems you're running for a reason -- to govern. To be good at it.

Well even if you aren't president, we still need leadership, esp in times of a void in the White House.

repository: scripting/Scripting-News

gha_language: HTML

repo_name: scripting/Scripting-News


text:
---
title: "Peculiar Velocity Surveys Using Supernovae Discoveries from ZTF-II and the Vera C. Rubin Observatory"
date: 2020-12-03
draft: false

event: LineA Webinar

location: Virtual

summary: First results from DESI spectral subtractions
abstract: "The motions of galaxies on top of the Hubble expansion, peculiar velocities, are a probe of clustering and the growth of structure in the Universe. For distance indicators, peculiar velocities manifest themselves as residuals on the Hubble diagram. Ongoing and upcoming wide-field surveys measuring unprecedented numbers of distance indicators, together with improvements in the calibration of Type Ia supernova brightnesses, will provide exquisite precision in the mapping of the peculiar velocity field or more precisely the peculiar distance field. There is an international effort to organize follow-up resources to obtain redshifts, classifications, and distance measurements of transients from DESI, the Zwicky Transient Facility (ZTF), ZTF-II, and the Rubin Observatory in order to produce compelling constraints on the laws of gravity responsible for the growth of structure."

# Talk start and end times.
#   End time can optionally be hidden by prefixing the line with `#`.
# date: "2019-10-25T13:30"
#date_end: "2030-06-01T15:00:00Z"
all_day: false

# Schedule page publish date (NOT talk date).
#publishDate: "2017-01-01T00:00:00Z"

authors: [Alex Kim]
tags: []

# Is this a featured talk? (true/false)
featured: true

#image:
#  caption: 'Image credit: [**Unsplash**](https://unsplash.com/photos/bzdhc5b3Bxs)'
#  focal_point: Right

links:
- icon: twitter
  icon_pack: fab
  name: Follow
  url: https://twitter.com/alexgykim
url_code: ""
url_pdf: "https://www.alexgkim.com/files/talks/seminars/LINEA.pdf"
# url_slides: "https://www.alexgkim.com/files/talks/seminars/LINEA.key"
url_video: "https://www.youtube.com/watch?v=HGNfzZmPHAA&feature=youtu.be"

# Markdown Slides (optional).
#   Associate this talk with Markdown slides.
#   Simply enter your slide deck's filename without extension.
#   E.g. `slides = "example-slides"` references `content/slides/example-slides.md`.
#   Otherwise, set `slides = ""`.
slides: ""

# Projects (optional).
#   Associate this post with one or more of your projects.
#   Simply enter your project's folder or file name without extension.
#   E.g. `projects = ["internal-project"]` references `content/project/deep-learning/index.md`.
#   Otherwise, set `projects = []`.
#projects:
#- internal-project

# Enable math on this page?
math: true
---

repository: AlexGKim/academic-kickstart

repo_name: AlexGKim/academic-kickstart


text:
# vCenter Server Appliance Terraform Module

Terraform module which creates a vCenter Server Appliance virtual machine in a vSphere environment.

The module presently assumes you are deploying from a machine with `bash`, `curl`, and `jq` installed.

The module has been tested with:

* `VMware-vCenter-Server-Appliance-<IP_ADDRESS>00-17327517_OVF10.ova`
* `VMware-vCenter-Server-Appliance-<IP_ADDRESS>00-17694817_OVF10.ova`

Other versions may or may not work correctly.

<!-- BEGINNING OF PRE-COMMIT-TERRAFORM DOCS HOOK -->
## Requirements

| Name | Version |
|------|---------|
| terraform | >= 0.13 |
| vsphere | >= 1.25.0 |

## Providers

| Name | Version |
|------|---------|
| random | n/a |
| vsphere | >= 1.25.0 |

## Modules

No Modules.

## Resources

| Name |
|------|
| [random_password](https://registry.terraform.io/providers/hashicorp/random/latest/docs/resources/password) |
| [vsphere_ovf_vm_template](https://registry.terraform.io/providers/hashicorp/vsphere/latest/docs/data-sources/ovf_vm_template) |
| [vsphere_virtual_machine](https://registry.terraform.io/providers/hashicorp/vsphere/latest/docs/resources/virtual_machine) |

## Inputs

| Name | Description | Type | Default | Required |
|------|-------------|------|---------|:--------:|
| cpu\_count\_override | The number of CPUs the vCenter Server Appliance should have. Defaults to 0 which uses the CPU count of the deployment selected. | `number` | `0` | no |
| datacenter\_id | The ID of the dataceter the vCenter Server Appliance should be created in. | `string` | n/a | yes |
| datastore\_id | The ID of the datastore the vCenter Server Appliance should be created in. | `string` | n/a | yes |
| deployment\_size | The deployment size of the vCenter Server Appliances.  Defaults to "tiny". | `string` | `"tiny"` | no |
| dns | The DNS server(s) for the vCenter Server Appliance. This defaults to "" which results in DHCP being used. Must be set if a static IP is set in `ip_address`. | `string` | `""` | no |
| enable\_ceip | Should the Customer Experience Improvement Program (CEIP) be enabled for the vCenter Server Appliance? Defaults to `false` | `bool` | `false` | no |
| enable\_ssh | Should SSH be enabled on the vCenter Server Appliance? Defaults to `false`. | `bool` | `false` | no |
| folder\_name | The name of the vm folder the vCenter Server Appliance should be created in. | `string` | n/a | yes |
| gateway | The gateway of the vCenter Server Appliance. This defaults to "" which results in DHCP being used. Must be set if a static IP is set in `ip_address` | `string` | `""` | no |
| host\_system\_id | The ID of the host system that the vCenter Server Appliance OVA will be initially deployed on. | `string` | n/a | yes |
| hostname | The FQDN of the vCenter Server Appliance. DNS records must exist ahead of provisioning or DDNS must be working in the environment. | `string` | n/a | yes |
| ip\_address | The IP address of the vCenter Server Appliance. This defaults to "" which results in DHCP being used. | `string` | `""` | no |
| mac\_address | The MAC address of the vCenter Server Appliance. This defaults to "" which results in a MAC address being generated. | `string` | `""` | no |
| memory\_override | The ammount of memory the vCenter Server Appliance should have. Defaults to 0 which uses the memory size of the deployment selected. | `number` | `0` | no |
| network\_id | The ID of the network the vCenter Server Appliance should be attached to. | `string` | n/a | yes |
| ntp | The NTP server for the vCenter Server Appliance. Defaults to "pool.ntp.org". | `string` | `"pool.ntp.org"` | no |
| ova\_path | The full path to the vCenter Server Appliance OVA. | `string` | n/a | yes |
| prefix | The subnet of the vCenter Server Appliance in CIDR format. This defaults to `null`. Must be set if a static IP is set in `ip_address`. | `number` | `null` | no |
| provisioner\_timeout | The max amount of time to wait in minutes for the vCenter Server Appliance to become available after provisioning | `number` | `60` | no |
| resource\_pool\_id | The ID of the resource pool the vCenter Server Appliance should be created in. | `string` | n/a | yes |
| sso\_domain\_name | The name of the internal SSO domain.  Defaults to "vsphere.local". | `string` | `"vsphere.local"` | no |

## Outputs

| Name | Description |
|------|-------------|
| administrator\_password | The password of the default VMware SSO Administrator. |
| administrator\_user | The full username of the default VMware SSO Administrator. |
| root\_password | The root password that was generated for the vCenter Server Appliance. |
<!-- END OF PRE-COMMIT-TERRAFORM DOCS HOOK -->

branch_name: refs/heads/main


text:
Compilerjs

Creating a compiler from scratch using JavaScript

---
# Compiler phases

## Evaluator

In it we simply visit each node from the tree with pre-order traversal and either:

-   Return the corresponding value, in case the node is of type number.

-   Perform the corresponding arithmetic operation, in case of an operation node.

### evaluate

Evaluate the expression and return the result.

**Parameters**

-   `ast` **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)** The AST.

Returns **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** The result.

### doOperation

Resolve the operation and returns the result.

**Parameters**

-   `ast` **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)** The AST.

## Lexer

The lexer is responsible for turning the input string into a list of tokens.

For instance, the lexer will turn the following expression:

sum 5 sub 2 mul 3 1 sum 4

To the following array:

["sum", "5", "sub", "2", "mul", "3", "1", "sum", "4"]

### lex

Generate all the tokens of the grammar.

The grammar string is splitted by a single space. Then the produced
substrings are mapped to their trimmed version and the empty
strings are filtered.

**Parameters**

-   `grammar` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** The grammar to be processed.

Returns **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)** an array of tokens.

## Parser

The parser is responsible for turing the list of tokens
into an AST or Abstract Syntax Tree.

Usually, the parser is implemented base on a grammar.

Here’s the grammar of our language:

digit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
num = digit+
op = sum | sub | mul | div
expr = num | op expr+

 Visually, the parsing is a process which turns the array:

const tokens = ["sub", "2", "sum", "1", "3", "4"];

to the following tree:

   sub
   / \
  2  sum
     /|\
    1 3 4

### parse

Define a variable to reference the node being processed
and call parseExpr.

**Parameters**

-   `tokens` **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** The array of tokens given by the lexer.

Returns **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)** An AST.

### peek

Returns the element of tokens associated with the current
value of the c local variable.

Returns **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)**

### consume

Returns the element of tokens associated with the current
value of the c local variable and increments c.

Returns **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)**

### parseNum

Gets the current token (i.e. invokes peek()), parses it to a
natural number and returns a new number token.

Returns **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)** A number node.

### parseOp

Since parseOp has been invoked by parseExpr when the value of peek()
is not a number we know that it is an operator so we create a new operation node.
In the node declaration we set the list of “sub-expressions” to
be the empty list (i.e. \[]), the operation name to the value of peek()
and the type of the node to Op. Later, while we don’t reach the end of
the program, we loop over all tokens by pushing the currently parsed expression
to the list of “sub-expressions\` of the given node. Finally, we return the node.

Returns **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)** An operation node.

### parseExpr

Checks if the current token matches the regular expression /\\d/
(i.e. is a number) and invokes parseNum if the match was successful,
otherwise returns parseOp.

Returns **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)**

## Transpiler

Instead of interpreting the AST, we can translate it to
another language. Here's how we can do that with JavaScript.

### transpileNum

Get the number node transpiled.

**Parameters**

-   `ast` **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)** The AST.

Returns **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** Number node transpiled.

### transpileOp

Get the operation node transpiled.

**Parameters**

-   `ast` **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)** The AST.

Returns **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** Operation node transpiled.

### transpileNode

Get the node transpiled.

**Parameters**

-   `ast` **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)** The AST.

Returns **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** Node transpiled.

### transpile

Transpile the AST to JavaScript code.

**Parameters**

-   `ast` **[Object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)** The AST.

Returns **[String](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String)** JavaScript code.

---
## License

[MIT](https://choosealicense.com/licenses/mit/)

repository: lhbelfanti/compilerjs

repo_name: lhbelfanti/compilerjs


text:
---
id: testing
title: 'Unit Testing'
sidebar_label: 'Unit Testing'
---

### What is Shallow Renderer in React testing?

_Shallow rendering_ is useful for writing unit test cases in React. It lets you render a component _one level deep_ and assert facts about what its render method returns, without worrying about the behavior of child components, which are not instantiated or rendered.

###### For example, if you have the following component:

```javascript
function MyComponent() {
  return (
    <div>
      <span className={'heading'}>{'Title'}</span>
      <span className={'description'}>{'Description'}</span>
    </div>
  );
}
```

###### Then you can assert as follows:

```jsx harmony
import ShallowRenderer from 'react-test-renderer/shallow';

// in your test
const renderer = new ShallowRenderer();
renderer.render(<MyComponent />);

const result = renderer.getRenderOutput();

expect(result.type).toBe('div');
expect(result.props.children).toEqual([
  <span className={'heading'}>{'Title'}</span>,
  <span className={'description'}>{'Description'}</span>,
]);
```

---

### What is `TestRenderer` package in React?

This package provides a renderer that can be used to render components to pure JavaScript objects, without depending on the DOM or a native mobile environment. This package makes it easy to grab a snapshot of the platform view hierarchy (similar to a DOM tree) rendered by a ReactDOM or React Native without using a browser or `jsdom`.

```jsx harmony
import TestRenderer from 'react-test-renderer';

const Link = ({page, children}) => <a href={page}>{children}</a>;

const testRenderer = TestRenderer.create(
  <Link page={'https://www.facebook.com/'}>{'Facebook'}</Link>,
);

console.log(testRenderer.toJSON());
// {
//   type: 'a',
//   props: { href: 'https://www.facebook.com/' },
//   children: [ 'Facebook' ]
// }
```

---

### What is the purpose of ReactTestUtils package?

_ReactTestUtils_ are provided in the `with-addons` package and allow you to perform actions against a simulated DOM for the purpose of unit testing.

---

## What is Jest?

_Jest_ is a JavaScript unit testing framework created by Facebook based on Jasmine and provides automated mock creation and a `jsdom` environment. It's often used for testing components.

---

### What are the advantages of Jest over Jasmine?

There are couple of advantages compared to Jasmine:

- Automatically finds tests to execute in your source code.
- Automatically mocks dependencies when running your tests.
- Allows you to test asynchronous code synchronously.

- Runs tests in parallel processes so that they finish sooner.

---

### Give a simple example of Jest test case

Let's write a test for a function that adds two numbers in `sum.js` file:

```javascript
const sum = (a, b) => a + b;

export default sum;
```

Create a file named `sum.test.js` which contains actual test:

```javascript
import sum from './sum';

test('adds 1 + 2 to equal 3', () => {
  expect(sum(1, 2)).toBe(3);
});
```

And then add the following section to your `package.json`:

```json
{
  "scripts": {
    "test": "jest"
  }
}
```

Finally, run `yarn test` or `npm test` and Jest will print a result:

```shell
    $ yarn test
    PASS ./sum.test.js
    ✓ adds 1 + 2 to equal 3 (2ms)
```

---

repository: krishnaUIDev/UI-Kit

gha_language: JavaScript

gha_license_id: MIT

repo_name: krishnaUIDev/UI-Kit


text:
---
layout: about
permalink: /
title: Deep Reinforcement Learning
description: 10-703 • Fall 2020 • Carnegie Mellon University
logo: cmu-logo.png
news: true
---

This course brings together many disciplines of Artificial Intelligence (including computer vision, robot control, reinforcement learning, language understanding) to show how to develop intelligent agents that can learn to sense the world and learn to act by imitating others, maximizing sparse rewards, and/or satisfying their curiosity.

Upon completion of this course, you should be able to
- Implement and experiment with existing state-of-the-art methods for learning behavioral policies supervised by reinforcement, demonstrations and/or intrinsic curiosity.
- Evaluate the sample complexity, generalization and generality of these algorithms.
- Understand research papers in the field of robotic learning.
- Try out ideas/extensions on existing methods.

***

- **Lectures:** Monday, Wednesday 11:40-1:00pm
- **Recitations:** Friday 11:40-1:00pm

- **Discussion:** [Piazza](https://piazza.com){:target="\_blank"}
- **HW submission:** [Gradescope](https://www.gradescope.com){:target="\_blank"}
- **Contact:** For external enquiries, personal matters or in emergencies, you can email us at<EMAIL_ADDRESS>
***


text:
# KScorrect 1.3.1 (2019-01-05)
* Changed spline method from default to 'hyman' in qmixnorm that is more appropriate for handling monotonic sequences, and improves performance under certain mixture models. (Thanks to Qiong Zhang for catching the error.)

# KScorrect 1.2.5 (2018-09-17)
* Changed number of randomly generated samples per mixture components ('nr') to 1000, to match help file text. nr=1000 is much faster and nearly equally precise.

# KScorrect 1.2.4 (2018-08-14)
* Silenced 'verbose' arg when calling 'mclust' functions

# KScorrect 1.2.3 (2018-02-23)
* Reformatted functions to Google / Hadley style

# KScorrect 1.2.2 (2017-04-23)
* Clarify text so better explains behavior based on 'mclust' package functions.

# KScorrect 1.2.1 (2017-01-10)
* Improved text, with corrected textual errors

# KScorrect 1.2.0 (2016-03-19)
* Text clarifications to Help files prior to posting to CRAN.
* Removed calculation of standard error in LcKS.

# KScorrect 1.1.0
* Steve Wang re-wrote qmixnorm to improve performance and make the function more compatible with behavior in other quantile functions, such as qnorm.
* Improved handling of extreme probabilities in qmixnorm, based on algorithm by Luca Scrucca.
* Corrected behavior when single 'sd' specified in mixture model functions so that results in equal-variance mixture model, and calls warning to alert to behavior

# KScorrect 1.0.0
* First release (to GitHub).

repository: gaow/KScorrect

repo_name: gaow/KScorrect


text:
---
layout: post
title:  "Discord Bots"
date:   2017-07-31
excerpt: "Various bots for Discord"
project: true
tag:
- ruby
- discordrb
- api
comments: false
---

After a request from a friend who runs a Discord server that I had recently joined, I began to experiment with creating simple bots, as small projects that nevertheless have clear and immediate front-end uses.

My first bot was [Makkachin](https://github.com/i-hardy/makkachin-bot), a bot whose primary function is to create a 'sprint timer' for creative writing challenges- a timer can be set for a custom length of time, and users can opt in to be @-notified of its start and end. The bot also uses regex matching to fetch gifs via the Giphy API.

repository: i-hardy/personal-website

repo_name: i-hardy/personal-website


text:
# Envoy client

A DER client for a 2030.5 server. Currently this is only a simple implementation of
device registration as an aggregator. This will later be expanded to cover more complex
examples of both Aggregator Client and DER Client models.

# Usage

This library is a very bare implementation, but can be used in two modes:
- mock requests: in this mode, the client prints out requests that would be made
for a given registration process. This is useful if implementing the client in a different
language
- real requests: use client certificate authentication to interact with a real server.

A simple example making mock requests for an example system can be found in
`scripts/generate_examples.py`. The usage examples below are based on this script.

## Authorisation

Every request must use TLS client-side certificates to authenticate/authorise with the
utility server. For interacting with the server, the simplest usage of this library is:

```python
from envoy_client.client import AggregatorClient
from envoy_client.transport import RequestsTransport
from envoy_client.auth import ClientCerticateAuth

cert_path = '/path/to/client.cert'
# The aggregator LFDI (long-form device identifier) is derived
# from the client certificate and will be supplied to the aggregator/client
aggregator_lfdi = '0x21352135135'

client = AggregatorClient(
    transport=RequestsTransport(
        'https://server-location',
        auth=ClientCertificateAuth(
            cert=cert_path
        )),
    lfdi=aggregator_lfdi
)
```

## Registration

Under the 2030.5 server model, registration of a device requires a non-neglible number of
requests. The registration process requires all or most of these:
- create `EndDevice`
- add `DeviceInformation` to the `EndDevice`
- add associated `DER` containers to the `EndDevice`
- populate `DERCapability` for each associated `DER`
- register the `EndDevice` to an associated `ConnectionPoint`

These steps are explained in more detail below.

### POST EndDevice

This registers the `EndDevice` with the server, which corresponds (essentially) to the site
controller. Note that under the aggregator model, the aggregator is also an `EndDevice`.

> Note: The long-form device identifier (LFDI) is a 160-bit unique identifier that is normally
displayed as a hexadecimal string. For `EndDevice`s that use a TLS certificate to communicate
with the server (e.g. the aggregator itself), this is derived from the certificate fingerprint.
For `EndDevice`s that do not have a certificate issued, (e.g. aggregator-managed controllers),
this should correspond to a globally unique identifier that the aggregator already uses,
appropriately padded or truncated. (Note that, since the short-form device identifier (SFDI)
is based on the left-truncated 36 bits of the LFDI, the LFDI should not be left-padded).

> When using the models in this library, the SFDI is automatically calculated from the supplied
LFDI. If implemented separately, use the following information:

> The SFDI SHALL be the certificate fingerprint left-truncated to 36 bits. For display purposes, this SHALL be expressed as 11 decimal (base 10) digits, with an additional sum-of-digits checksum digit right- concatenated. For example:
LFDI left truncated to 36 bits: 0x3E4F45AB3
Expressed as a decimal:<PHONE_NUMBER>9
Checksum added:<PHONE_NUMBER>91

#### Example
```
POST https://server-location/edev
Content-Type: application/xml

<?xml version="1.0" encoding="utf-8"?>
<EndDevice>
        <deviceCategory>262144</deviceCategory>
        <lFDI>0x21352135135</lFDI>
        <sFDI>356563223726</sFDI>
        <changedTime>0</changedTime>
        <postRate>0</postRate>
        <enabled>true</enabled>
</EndDevice>

```

The server responds with a `201: CREATED` response and a header `location: /edev/3`
to indicate the location of the created resource. This value is then used in the subsequent
requests and is referenced in these examples as {edevID}

### PUT DeviceInformation

`DeviceInformation` contains identification and other information about the device that changes very infrequently, typically only when updates are applied, if ever.

#### Example

```
PUT https://server-location/edev/1/di
Content-Type: application/xml

<?xml version="1.0" encoding="utf-8"?>
<DeviceInformation>
        <functionsImplemented>524288</functionsImplemented>
        <gpsLocation>
                <lat>-35.0</lat>
                <lon>144.0</lon>
        </gpsLocation>
        <lFDI>1172794507551</lFDI>
        <mfDate>0</mfDate>
        <mfHwVer>foo</mfHwVer>
        <mfID>1234567</mfID>
        <mfInfo>Acme Corp</mfInfo>
        <mfModel>Acme 2000 Pro+</mfModel>
        <mfSerNum>ACME1234</mfSerNum>
        <primaryPower>0</primaryPower>
        <secondaryPower>0</secondaryPower>
        <swActTime>0</swActTime>
        <swVer>NA</swVer>
</DeviceInformation>
```

### POST DER
An `EndDevice` can have multiple `DER` resources linked to it. For the purposes of this
example, it is assumed that there is only a single `DER` resource under each `EndDevice`.

```
POST https://server-location/edev/{edevID}/der
Content-Type: application/xml

<?xml version="1.0" encoding="utf-8"?>
<DER></DER>
```

The server responds with a `201: CREATED` response and a header `location: /edev/{edevID}/der/5`
to indicate the location of the resource. For the following examples, this is referenced by
{derID}.

### PUT DER Capability
While a `DER` resource can contain information about `DERSettings`, `DERStatus`, `DERCapability`
and `DERAvailability`, we are only interested in `DERCapability`, which exposes the nameplate
ratings of the DER.

#### Example

```
PUT https://server-location/edev/{edevID}/der/{derID}/dercap
Content-Type: application/xml

<?xml version="1.0" encoding="utf-8"?>
<DERCapability>
        <modesSupported>1</modesSupported>
        <rtgMaxW>
                <value>5000</value>
                <multiplier>0</multiplier>
        </rtgMaxW>
        <type>83</type>
</DERCapability>
```

### PUT ConnectionPoint

This is an extension to the standard that allows the aggregator or DER client to provide
additional information about the identification of the connection point to which the
device is connected (generally for metering purposes).

#### Example

The client PUTs a `ConnectionPoint` object containing the site NMI (as `meterID`).

```
PUT https://server-location/edev/1/cp
Content-Type: application/xml

<?xml version="1.0" encoding="utf-8"?>
<ConnectionPoint>
        <connectionPointID></connectionPointID>
        <meterID>NMI123</meterID>
</ConnectionPoint>
```

Server responds with `200: OK`.

repository: YellowDotPink/envoy-client

repo_name: YellowDotPink/envoy-client


text:
# force-pip-chrome-extension
A quick and dirty Chrome extension to force Picture-In-Picture mode on sites that hide the functionality.

![](https://media0.giphy.com/media/BammSQz8IqVT8I0Z0U/giphy.gif?cid=790b7611faaee1b455a37c950f7fa33b23cea042b0369a3d&rid=giphy.gif&ct=g)

# Tested on sites:
- Hybeflex
- Youtube

# Installation see:
- Goto: chrome://extensions OR navigate (menu -> Tools -> Extensions).
- Enable Developer mode by ticking the checkbox in the upper-right corner.
- Click on the "Load unpacked" button.
- Select the force-pip-chrome-extension


text:
# ComplementDrugSearch

## Table of contents

* [Introduction](#introduction)
* [Download](#download)
* [Usage](#usage)
  * [Help](#help)
  * [Drug](#drug)
  * [Proteins](#proteins)

## Introduction

Welcome to the ComplementDrugSearch repository!

This is a C# / .NET Core application which aims to identify possible drugs that complement a given drug acting on a directed protein-protein interaction network. The application is cross-platform, working on all modern operating systems (Windows, MacOS, Linux) and can be run through CLI (command-line interface).

## Download

The repository consists of a Visual Studio 2019 project. You can download it to run or build the application yourself. You need to have [.NET Core 3.1](https://dotnet.microsoft.com/download/dotnet-core/3.1) installed on your computer in order to run it, or the corresponding SDK in order to also be able to build it.

## Usage

Open your operating system's terminal or console and navigate to the `ComplementDrugSearch` folder (the one containing the file `Program.cs`). There, you can run the application with:

```
dotnet run
```

### Help

In order to find out more about the usage and possible arguments which can be used, you can launch the application with the `--Mode` argument set to `Help` (or omit it entirely), for example:

```
--Mode "Help"
```

### Drug

To run the application starting from an initial drug, you can launch it from the terminal with the `--Mode` argument set to `Drug`, for example:

```
--Mode "Drug"
```

This mode has four mandatory arguments (omitting any of them will return an error) and four optional ones:

* ``--Interactions``. Use this argument to specify the path to the file containing the protein-protein interactions. Each interaction should be on a new line, with its elements separated by semicolons. Each interaction should contain the source protein, the target protein, and the type (`-1` for a down-regulating interaction or equivalent, `1` for an up-regulating interaction or equivalent, or `0` otherwise), for example:

  ```
  Protein A;Protein B;-1
  Protein A;Protein C;1
  Protein A;Protein D;1
  Protein C;Protein D;0
  ```

  If the file is in a different format, or no proteins or interactions could be found, an error will be returned. The order of the proteins is important, as the network is directed. Thus, `Protein A;Protein B` is not the same as `Protein B;Protein A`, and they can both appear in the network. Any duplicate interactions will be ignored. The set of proteins in the network will be automatically inferred from the set of interactions. This argument does not have a default value.

* `--Drugs`. Use this argument to specify the path to the file containing the possible drugs. Each drug should be on a new line, with its elements separated by semicolons. Each drug should contain the drug name, the corresponding drug-target, and the type (`-1` for a drug that down-regulates its drug-target, `1` for a drug that up-regulates its drug-target, or `0` otherwise), for example:

  ```
  Drug 1;Protein A;-1
  Drug 3;Protein C;1
  ```

  If the file is in a different format, or no drugs could be found with drug-targets in the network, an error will be returned. Only the drugs with drug-targets in the network will be considered. Any duplicate drugs will be ignored. This argument does not have a default value.

* `--DiseaseEssentialProteins`. (optional) Use this argument to specify the path to the file containing the disease-essential proteins. Each protein should be on a new line.

  ```
  Protein A
  Protein D
  ```

  If the file is in a different format, or no proteins could be found in the network, an error will be returned. Only the proteins which already appear in the network will be considered. Any duplicate proteins will be ignored. This argument does not have a default value and can be omitted if healthy-essential proteins are provided.

* `--HealthyEssentialProteins`. (optional) Use this argument to specify the path to the file containing the healthy-essential proteins. Each protein should be on a new line.

  ```
  Protein B
  Protein C
  ```

  If the file is in a different format, or no proteins could be found in the network, an error will be returned. Only the proteins which already appear in the network will be considered. Any duplicate proteins will be ignored. This argument does not have a default value and can be omitted if disease-essential proteins are provided.

* `--Initial`. Use this argument to specify the name of the initial drug or drug-target. If the initial drug is not in the list of drugs or its corresponding drug-target does not appear in the network, an error will be returned. This argument does not have a default value.

* `--MaximumPath`. (optional) Use this argument to specify the length of the maximum path between the drug-targets and the essential proteins. It must be a positive integer. The default value is `3`.

* `--NumberOfSolutions`. (optional) Use this argument to specify the maximum number of complementing drugs to be returned. The default value is `10`.

* `--Output`. (optional) Use this argument to specify the path to the output file where the results will be written. Permission to write is needed for the corresponding directory. If a file with the same name already exists, it will be automatically overwritten. The default value is the name of the file containing the interactions, followed by the name of the initial drug, the name of its drug-target, and the current date and time.

### Proteins

To run the application starting from an initial list of proteins, you can launch it from the terminal with the `--Mode` argument set to `Proteins`, for example:

```
--Mode "Proteins"
```

This mode has four mandatory arguments (omitting any of them will return an error) and four optional ones:

* ``--Interactions``. Use this argument to specify the path to the file containing the protein-protein interactions. Each interaction should be on a new line, with its elements separated by semicolons. Each interaction should contain the source protein, the target protein, and the type (`-1` for a down-regulating interaction or equivalent, `1` for an up-regulating interaction or equivalent, or `0` otherwise), for example:

  ```
  Protein A;Protein B;-1
  Protein A;Protein C;1
  Protein A;Protein D;1
  Protein C;Protein D;0
  ```

  If the file is in a different format, or no proteins or interactions could be found, an error will be returned. The order of the proteins is important, as the network is directed. Thus, `Protein A;Protein B` is not the same as `Protein B;Protein A`, and they can both appear in the network. Any duplicate interactions will be ignored. The set of proteins in the network will be automatically inferred from the set of interactions. This argument does not have a default value.

* `--Drugs`. Use this argument to specify the path to the file containing the possible drugs. Each drug should be on a new line, with its elements separated by semicolons. Each drug should contain the drug name, the corresponding drug-target, and the type (`-1` for a drug that down-regulates its drug-target, `1` for a drug that up-regulates its drug-target, or `0` otherwise), for example:

  ```
  Drug 1;Protein A;-1
  Drug 3;Protein C;1
  ```

  If the file is in a different format, or no drugs could be found with drug-targets in the network, an error will be returned. Only the drugs with drug-targets in the network will be considered. Any duplicate drugs will be ignored. This argument does not have a default value.

* `--DiseaseEssentialProteins`. (optional) Use this argument to specify the path to the file containing the disease-essential proteins. Each protein should be on a new line.

  ```
  Protein A
  Protein D
  ```

  If the file is in a different format, or no proteins could be found in the network, an error will be returned. Only the proteins which already appear in the network will be considered. Any duplicate proteins will be ignored. This argument does not have a default value and can be omitted if healthy-essential proteins are provided.

* `--HealthyEssentialProteins`. (optional) Use this argument to specify the path to the file containing the healthy-essential proteins. Each protein should be on a new line.

  ```
  Protein B
  Protein C
  ```

  If the file is in a different format, or no proteins could be found in the network, an error will be returned. Only the proteins which already appear in the network will be considered. Any duplicate proteins will be ignored. This argument does not have a default value and can be omitted if disease-essential proteins are provided.

* `--Initial`. Use this argument to specify the path to the file containing the initial proteins. Each protein should be on a new line.

  ```
  Protein A
  Protein C
  ```

  If the file is in a different format, or no proteins could be found in the network, an error will be returned. Only the proteins which already appear in the network will be considered. Any duplicate proteins will be ignored. This argument does not have a default value.

* `--MaximumPath`. (optional) Use this argument to specify the length of the maximum path between the drug-targets and the essential proteins. It must be a positive integer. The default value is `3`.

* `--NumberOfSolutions`. (optional) Use this argument to specify the maximum number of complementing drugs to be returned. The default value is `10`.

* `--Output`. (optional) Use this argument to specify the path to the output file where the results will be written. Permission to write is needed for the corresponding directory. If a file with the same name already exists, it will be automatically overwritten. The default value is the name of the file containing the interactions, followed by the name of the file containing the initial proteins, and the current date and time.

repository: Vilksar/ComplementDrugSearch

repo_name: Vilksar/ComplementDrugSearch


text:
Simple Icons

Over 1500 Free SVG icons for popular brands. See them all on one page at SimpleIcons.org. Contributions, corrections & requests can be made on GitHub.

## Usage

> :information_source: We ask that all users read our [legal disclaimer](./DISCLAIMER.md) before using icons from Simple Icons.

### General Usage

Icons can be downloaded as SVGs directly from [our website](https://simpleicons.org/) - simply click the icon you want, and the download should start automatically.

### CDN Usage

Icons can be served from a CDN such as [JSDelivr](https://www.jsdelivr.com/package/npm/simple-icons) or [Unpkg](https://unpkg.com/browse/simple-icons/). Simply use the `simple-icons` npm package and specify a version in the URL like the following:

```html
<img height="32" width="32" src="https://cdn.jsdelivr.net/npm/simple-icons@v5/icons/[ICON SLUG].svg" />
<img height="32" width="32" src="https://unpkg.com/simple-icons@v5/icons/[ICON SLUG].svg" />
```

Where `[ICON SLUG]` is replaced by the [slug] of the icon you want to use, for example:

```html
<img height="32" width="32"<EMAIL_ADDRESS>/>
<img height="32" width="32"<EMAIL_ADDRESS>/>
```

These examples use the latest major version. This means you won't receive any updates following the next major release. You can use `@latest` instead to receive updates indefinitely. However, this will result in a `404` error if the icon is removed.

### Node Usage

The icons are also available through our npm package. To install, simply run:

```shell
npm install simple-icons
```

The API can then be used as follows, where `[ICON SLUG]` is replaced by a [slug]:

```javascript
const simpleIcons = require('simple-icons');

// Get a specific icon by its slug as:
// simpleIcons.Get('[ICON SLUG]');

// For example:
const icon = simpleIcons.Get('simpleicons');

```

Alternatively you can import the needed icons individually, where `[ICON SLUG]` is replaced by a [slug].
This is useful if you are e.g. compiling your code with [webpack](https://webpack.js.org/) and therefore have to be mindful of your package size:

```javascript
// Import a specific icon by its slug as:
// require('simple-icons/icons/[ICON SLUG]');

// For example:
const icon = require('simple-icons/icons/simpleicons');
```

Either method will return an icon object:

```javascript
console.log(icon);

/*
{
    title: 'Simple Icons',
    slug: 'simpleicons',
    hex: '111111',
    source: 'https://simpleicons.org/',
    svg: '<svg role="img" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">...</svg>',
    path: 'M12 12v-1.5c-2.484 ...',
    guidelines: 'https://simpleicons.org/styleguide',
    license: {
        type: '...',
        url: 'https://example.com/'
    }
}

NOTE: the `guidelines` entry will be `undefined` if we do not yet have guidelines for the icon.
NOTE: the `license` entry will be `undefined` if we do not yet have license data for the icon.
*/
```

Lastly, the `simpleIcons` object is also enumerable.
This is useful if you want to do a computation on every icon:

```javascript
const simpleIcons = require('simple-icons');

for (const iconSlug in simpleIcons) {
    const icon = simpleIcons.Get(iconSlug);
    // do stuff
}
```

#### TypeScript Usage

There are also TypeScript type definitions for the Node package. To use them, simply run:

```shell
npm install @types/simple-icons
```

### PHP Usage

The icons are also available through our Packagist package. To install, simply run:

```shell
composer require simple-icons/simple-icons
```

The package can then be used as follows, where `[ICON SLUG]` is replaced by a [slug]:

```php
<?php
// Import a specific icon by its slug as:
echo file_get_contents('path/to/package/icons/[ICON SLUG].svg');

// For example:
echo file_get_contents('path/to/package/icons/simpleicons.svg');

// <svg role="img" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">...</svg>
?>
```

## Third Party Extensions

| Extension | Author |
| :--- | :--- |
| [Drupal module](https://www.drupal.org/project/simple_icons) | [Phil Wolstenholme](https://www.drupal.org/u/phil-wolstenholme) |
| [Flutter package](https://pub.dev/packages/simple_icons) | [@jlnrrg](https://jlnrrg.github.io/) |
| [Hexo plugin](https://github.com/nidbCN/hexo-simpleIcons) | [@nidbCN](https://github.com/nidbCN/) |
| [Home Assistant plugin](https://github.com/vigonotion/hass-simpleicons) | [@vigonotion](https://github.com/vigonotion/) |
| [Jetpack Compose library](https://github.com/DevSrSouza/compose-icons) | [@devsrsouza](https://github.com/devsrsouza/) |
| [Kirby plugin](https://github.com/runxel/kirby3-simpleicons) | [@runxel](https://github.com/runxel) |
| [Laravel Package](https://github.com/ublabs/blade-simple-icons) | [@adrian-ub](https://github.com/adrian-ub) |
| [Python package](https://github.com/sachinraja/simpleicons) | [@sachinraja](https://github.com/sachinraja) |
| [React package](https://github.com/icons-pack/react-simple-icons) | [@wootsbot](https://github.com/wootsbot) |
| [Svelte package](https://github.com/icons-pack/svelte-simple-icons) | [@wootsbot](https://github.com/wootsbot) |
| [Vue package](https://github.com/mainvest/vue-simple-icons) | [@noahlitvin](https://github.com/noahlitvin) |
| [WordPress plugin](https://wordpress.org/plugins/simple-icons/) | [@tjtaylo](https://github.com/tjtaylo) |

[slug]: ./slugs.md

branch_name: refs/heads/develop


text:
<!--
**Note on code generation issues**
Please open an issue in [Swagger Codegen](https://github.com/swagger-api/swagger-codegen) repository for any issue with generating code or issues with generated codes.
-->
**Swagger File**

```yaml
 # paste your swagger document here
```

* Version:
* Browser/OS:

**Issue**

gha_license_id: NOASSERTION


text:
---
title: Asset Sentiment
last_updated: June 8, 2016
sidebar: api_sidebar
permalink: /api-asset-sentiment/
---

The asset sentiment endpoint will return a list of sentiment objects. The default view is the current day’s sentiment data for a single asset based on the specified {identifier} value. The date which the data refers to is also returned in the request

```
GET /assets/{identifier}/sentiment/
```

For API consumers that have licensed our historical sentiment data there are optional parameters to get sentiment for a specified date range

Parameter	Format	Description

startdate	date - (YYYYMMDD)	the first day in the requested range

enddate	date - (YYYYMMDD)	the last day in the requested range

The asset sentiment endpoint will adhere to the following behaviour:

1. If no start date or end date is provided the data will be for the current day only.
2. If there is no start date, the data will be returned for the end date only.
3. If there is no end date, the data range will span from the start date provided up until the current day.
4. If the start date is after the end date, the start date will be ignored and the API will adhere to the step 3.

### Example request/response

JSON Response

```
GET https://api.knows.is/assets/$ARMH/sentiment/?startdate=20121231&enddate=20130101
Accept: application/json, text/javascript
```

```
{
  "name": "ARM Holdings PLC",
  "identifier": "$ARMH",
  "startdate": "2012-12-31T00:00:00Z",
  "enddate": "2013-01-02T00:00:00Z",
  "datapoints": [
    {
      "date": "2013-01-01T00:00:00Z",
      "sentiment": {
        "current": -19,
        "previous": -4,
        "change": -15
      },
      "volume": {
        "change": 6
      }
    },
    {
      "date": "2012-12-31T00:00:00Z",
      "sentiment": {
        "current": -4,
        "previous": -40,
        "change": 36
      },
      "volume": {
        "change": 456
      }
    }
  ]
}
```


text:
# FPGA Tools

Handy Python tools for FPGA development by [Project F](https://projectf.io/). For our Verilog designs see [projf-explore](https://github.com/projf/projf-explore).

Licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

## img2fmem

Image to FPGA memory map converter for use with Verilog `$readmemh()` or Xilinx core generator COE.
Output hex image uses 16, 64, or 256 colours from a 12 or 24-bit palette.
Written in Python 3 using the [Pillow](https://pillow.readthedocs.io) package.

Your source image needs to be in a format Pillow supports: PNG, JPEG, TIFF, BMP are amongst the formats supported.

For full usage instructions see the [img2fmem README](img2fmem/).

## sine2fmem

Generate a table of sine values between 0-90° (0 - π/2 radians) suitable for
loading into memory with Verilog `$readmemh()`.

For usage instructions see the [sine2fmem README](sine2fmem/).

## wf2fmem

Wavefront .obj (3D model) to FPGA memory init file converter for use with Verilog `$readmemh()`.
Handles triangular and quad faces. Written in Python 3.

For usage instructions see the [wf2fmem README](wf2fmem/).

repository: wil-low/fpgatools

repo_name: wil-low/fpgatools


text:
# Tracker

Tracker is a gem for tracking events in Rails applications. It hooks in Rack to send page events automatically. Inspired by https://github.com/railslove/rack-tracker.

## Installation

```ruby
gem 'tracker'
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install tracker

## Usage

* use as middleware

```ruby
# config/application.rb
config.middleware.use(Tracker::Middleware) do
  # register handlers
  handler(
    queue_class:  Tracker::GoogleAnalytics::Queuer,
    client_class: Tracker::GoogleAnalytics::Client,
    opts:         { api_key: "" }
  )

  # specify which background worker to use to async send events
  queuer Tracker::Background::Sidekiq

  # specify how to get UUID for user from env
  uuid do |env|
    env["UUID"]
  end

  # specify paths to be ignored by page tracker
  ignore_paths ["/path", "/path/with-matcher/*", "/path/*/matchers"]

  # specify how to get the session; this is implemented in Amplitude
  # in order to determine user session time length
  session do |env|
    env["SOME_SESSION_VALUE"]
  end
end

# in a controller
queue_tracker do |t|
  t.page(path: "/path", page_args: {a: 1})
  t.event(name: "event_name", event_args: {a: 2})
end
```

## Development

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

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

## Contributing

Bug reports and pull requests are welcome on GitHub at https://github.com/WalkerAndCoBrandsInc/tracker

## License

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

repository: WalkerAndCoBrandsInc/tracker

gha_language: Ruby

repo_name: WalkerAndCoBrandsInc/tracker


text:
# Jack the Reader [![Wercker build badge][wercker_badge]][wercker] [![codecov](https://codecov.io/gh/uclmr/jack/branch/master/graph/badge.svg?token=jbZrj9oSmi)](https://codecov.io/gh/uclmr/jack) [![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/jack-the-reader/Lobby?source=orgpage) [![license](https://img.shields.io/github/license/mashape/apistatus.svg?maxAge=2592000)](https://github.com/uclmr/jack/blob/master/LICENSE)

##### A reading comprehension framework.

* All work and no play makes Jack a great frame*work*!
* All work and no play makes Jack a great frame*work*!
* All work and no play makes Jack a great frame*work*!

[wercker_badge]: https://app.wercker.com/status/8ed61192a5b16769a41dc24c30a3bc6a/s/master
[wercker]: https://app.wercker.com/project/byKey/8ed61192a5b16769a41dc24c30a3bc6a
[heres_johnny]: https://upload.wikimedia.org/wikipedia/en/b/bb/The_shining_heres_johnny.jpg

**Jack the Reader** -- or **jack**, for short -- is a framework for building an testing models on a variety of tasks that require *reading comprehension*.

To get started, please see [How to Install and Run][install] and then you may
want to have a look at the [notebooks][notebooks].  Lastly, for a high-level explanation of the ideas and
vision, see [Understanding Jack the Reader][understanding].

[install]: docs/How_to_install_and_run.md
[api]: https://uclmr.github.io/jack/
[notebooks]: notebooks/
[understanding]: docs/Understanding_Jack_the_Reader.md

# Quickstart Examples - Training and Usage of a Question Answering System

To illustrate how jack works, we will show how to train a question answering
model.

### Extractive Question Answering on SQuAD

First, download SQuAD and GloVe embeddings:

```bash
$ data/SQuAD/download.sh
$ data/GloVe/download.sh
$ # Although we support native glove format it is recommended to use a memory mapped format which allows to load embeddings only as needed.
$ python3 ./bin/mmap-cli.py data/GloVe/glove.840B.300d.txt data/GloVe/glove.840B.300d.memory_map_dir
```

Train a [FastQA][fastqa] model:

```bash
$ python3 bin/jack-train.py with train='data/SQuAD/train-v1.1.json' dev='data/SQuAD/dev-v1.1.json' model='fastqa_reader' \
> repr_dim=300 dropout=0.5 batch_size=64 seed=1337 loader='squad' model_dir='./fastqa_reader' epochs=20 \
> with_char_embeddings=True embedding_format='memory_map_dir' embedding_file='data/GloVe/glove.840B.300d.memory_map_dir' vocab_from_embeddings=True
```

or shorter, using our prepared config:

```bash
$ python3 bin/jack-train.py with config='./conf/fastqa.yaml'
```

You want to train another model with the same configuration (e.g., bidaf)? No problem, just change the `model` flag:

```bash
$ python3 bin/jack-train.py with config='./conf/fastqa.yaml' model=bidaf_reader
```

Note, you can add a flag `tensorboard_folder=.tb/fastqa` to write arbitrary tensorboard
[summaries][tf_summaries]  to a provided path (here `.tb/fastqa`). Your summaries are automatically
fetched in the train loop, so all you need to do is write them in your TF model code.

A copy of the model is written into the `model_dir` directory after each
training epoch when performance improves. These can be loaded using the commands below or see e.g.
[the showcase notebook][showcase].

If all of that is too cumbersome for you and you just want to play, why not downloading a pretrained model:

```bash
$ # we still need GloVe in memory mapped format, ignore the next 2 commands if already downloaded and transformed
$ data/GloVe/download.sh
$ python3 ./bin/mmap-cli.py data/GloVe/glove.840B.300d.txt data/GloVe/glove.840B.300d.memory_map_dir
$ wget http://data.neuralnoise.com/jack/extractive_qa/fastqa.zip
$ unzip fastqa.zip && mv fastqa fastqa_reader
```

```python
from jack import readers
from jack.core import QASetting

fastqa_reader = readers.reader_from_file("./fastqa_reader")

support = """"It is a replica of the grotto at Lourdes,
France where the Virgin Mary reputedly appeared to Saint Bernadette Soubirous in 1858.
At the end of the main drive (and in a direct line that connects through 3 statues and the Gold Dome),
is a simple, modern stone statue of Mary."""

answers = fastqa_reader([QASetting(
    question="To whom did the Virgin Mary allegedly appear in 1858 in Lourdes France?",
    support=[support]
)])
```

[fastqa]: https://arxiv.org/abs/1703.04816
[showcase]: notebooks/Showcasing_Jack.ipynb
[tf_summaries]: https://www.tensorflow.org/get_started/summaries_and_tensorboard

### Recognizing Textual Entailment on SNLI

First, download SNLI

```bash
$ # we still need GloVe in memory mapped format, ignore the next 2 commands if already downloaded and transformed
$ data/GloVe/download.sh
$ python3 ./bin/mmap-cli.py data/GloVe/glove.840B.300d.txt data/GloVe/glove.840B.300d.memory_map_dir
$ ./data/SNLI/download.sh
```

Then, for instance, train a [Decomposable Attention Model][dam]

```bash
$ python3 bin/jack-train.py with model='dam_snli_reader' loader=snli train='data/SNLI/snli_1.0/snli_1.0_train.jsonl' \
> dev='data/SNLI/snli_1.0/snli_1.0_dev.jsonl' test='data/SNLI/snli_1.0/snli_1.0_test.jsonl' \
> model_dir='./dam_reader' repr_dim=300 epochs=20 seed=1337 dropout=0.5 batch_size=64 \
> embedding_format='memory_map_dir' embedding_file='data/GloVe/glove.840B.300d.memory_map_dir' vocab_from_embeddings=True
```

or the short version:

```bash
$ python3 bin/jack-train.py with config='./conf/snli.yaml' model=dam_snli_reader model_dir='./dam_reader'
```

Note, you can easily change the model to one of the other implemented NLI readers (e.g., `cbilstm_snli_reader`, `esim_snli_reader`)

Note, you can add a flag `tensorboard_folder=.tb/dam_reader` to write tensorboard
summaries to a provided path (here `.tb/dam_reader`).

A copy of the model is written into the `model_dir` directory after each
training epoch when performance improves. These can be loaded using the commands below or see e.g.
[the showcase notebook][showcase].

```python
from jack import readers
from jack.core import QASetting

dam_reader = readers.reader_from_file("./dam_reader")

answers = dam_reader([QASetting(
    question="The boy plays with the ball.",  # Hypothesis
    support=["The boy plays with the ball."]  # Premise
)])
```

[dam]: https://arxiv.org/abs/1703.04816

# Support
We are thankful for support from:

# Developer guidelines

- [Comply with the PEP 8 Style Guide][pep8]
- Make sure all your code runs from the top level directory, e.g.:

```shell
$ python3 ./jack/io/SNLI2jtr_v1.py
```

[pep8]: https://www.python.org/dev/peps/pep-0008/


text:
---
title: Timer
signature: |
  npm install moment-timer
---

This is a Moment.js plugin that allows the use of timers, which offer much more control than the native JavaScript timers.
It's basically a rewrite of JavaScripts own setInterval and setTimeout.

For example,

```javascript
var timer = moment.duration(5, "seconds").timer({loop: true}, function() {
  // Callback
});
```

The repository is located at [github.com/SeverinDK/moment-timer](https://github.com/SeverinDK/moment-timer).


text:
# Lecture 19

## Events

### Creation/Destruction

* Declare event: ```cudaEvent_t myevent;```
* Create event: ```cudaEventCreate(&myevent);```
* Destroy event: ```cudaEventDestroy(&myevent);```

### Recording Events

* Events mark a point in stream execution.
* Can be used to chunk if executing stream operations have reached a given point.
* Think of them as operations added to the stream whose only action when popped ...

### Waiting on Events

* Blocks the calling host thread: ```cudaEventSynchronize(myevent);```
* Analagous to cudaStreamSynchronize();
* But allows host to wait for a specified intermediate point and not complete stream execution.

### Measuring elapsed time with Events

* Use ```cudaEventElapsedTime(&time, startevent, stopevent);``` with events.
  ```c
  cudaEvent_t start, stop;
  cudaEventCreate(&start);
  cudaEventCreate(&stop);
  cudaEventRecord(start);
  // launch kernel
  cudaEventRecord(stop);
  cudaEventSynchronize(stop);
  float time;
  cudaEventElapsedTime(&time, start, stop);
  cudaEventDestroy(start);
  cudaEventDestroy(stop);
  ```

## Host view of concurrency

* CUDA operations can be classified as:
  * Memory related ops; many are synchronous

## Non-null Streams

* Non-blocking on host
* But can be blocking (```cudaStreamCreate```) or Non-blocking on device.
* operations within a non-null stream can be blocked by operations in the NULL stream. NULL stream == blocking stream;
* Operations in a non-blocking stream won't block on ops in NULL stream.
  ```c
  Kernel1<<<1,1,0,stream1>>>();

  // this is blocking the other Streams
  Kernel2<<<1,1>>>();

  Kernel3<<<1,1,0,stream2>>>();
  ```

## Creating non-blocking Streams

* Use ```cudaStreamCreateWithFlags(cudaStream_t *mystream, unsigned int flag)```
* Where ```flag = cudaStreamNonBlocking```.
* if we used cudaStreamNonBlocking stream in previous example, none of the kernels would block.

## More on synchronization.

* Implicit synchronization
  * cudaMemcpy -> host blocks till data transfer complete.
  * Memory related operations on device typically wait for all previous operations on device to end:
    * Device Memory allocation
    * Device memset
    * Memcpy between addresses on same Device
    * Modification to L1/shared memory configuration
* Explicit synchronization
  * ```cudaDeviceSynchronize```
  * ```cudaStreamSynchronize```
  * ```cudaEventSynchronize```
  * ```cudaStreamWaitEvent```

## Atomic Operations

* Performs a mathematical operation, but does so in a single uninterruptable operation without any interference from other threads.
* Prevents the problem where an application needs threads to update a counter in shared memory
```c
__shared__ int counter;
// ...
if (/* ... */) counter++;
```
* Problem if two or more threads try to dio this at the same time.

* With atomic instructions, the read/add/write becomes a single operation, happening one after the other.

* Several different operations are supported, mostly only for integers.
  * Addition ```atomicAdd```
  * Min/Max ```atomicMin, atomicMax```
  * Inc/Dec
  * Unconditional swap (int and 32-bit float) ```atomicExch```
  * Subtraction
  * Compare-and-swap

## Atomic Compare-and-swap

* ```int atomicCAS (int *addr, int compare, int value)```
* if compare equals old value at address then val is stored instead.
* In either case, routine returns the value of old
* Seems a bizarre routine at first sight but can be very useful in atomic locks.
* Can also be used to implement 64-bit floating point atomic addition.

## Global Atomic locks

```c
// global variable: 0 = unlocked; 1 = locked
__device__ int lock=0;
__global__ void kernel()
{
  if (threadIdx.x == 0)
  {
    // set lock
    do {
      // do things
    } while (atomicCAS(&lock, 0, 1));

    // free lock.
    lock = 0;
  }
}
```

## Safe global atomic lock

```c
__device__ int lock=0;
__global__ void kernel ()
{
  if (threadIdx.x == 0) {
    do {} while (atomicCAS(&lock,0,1));
    __threadfence(); // wait for writes to finish -> introduces safety.
    lock = 0;
  }
}
```


text:
---
layout: post
title:  "It's Really Greasy"
date:   2019-12-27
author: can
categories: music
---

There is a lot of vinyl sampling going on here... Gotta love Ween <3

It's Really Greasy, Mommy by Can Trell

The instruments "Filth", "Vibez", and "Flute" from [**THIS FREE MPC INSTRUMENT PACK**]({% post_url 2019-12-17-tiny-samples %}) were also used in the making of this song.

repository: audiobird/audiobird

extension: markdown

repo_name: audiobird/audiobird


text:
# [918. Maximum Sum Circular Subarray](https://leetcode-cn.com/problems/maximum-sum-circular-subarray/)

![](https://img.shields.io/badge/Difficulty-Medium-F8AF40.svg)

Topics

* [`Array`](https://leetcode.com/tag/array/)
* [`Dynamic Programming`](https://leetcode.com/tag/dynamic-programming/)

Given a **circular integer array** `nums` of length `n`, return *the maximum possible sum of a non-empty **subarray** of `nums`*.

A **circular array** means the end of the array connects to the beginning of the array. Formally, the next element of `nums[i]` is `nums[(i + 1) % n]` and the previous element of `nums[i]` is `nums[(i - 1 + n) % n]`.

A **subarray** may only include each element of the fixed buffer `nums` at most once. Formally, for a subarray `nums[i], nums[i + 1], ..., nums[j]`, there does not exist `i <= k1`, `k2 <= j` with `k1 % n == k2 % n`.

**Example 1:**

```
Input: nums = [1,-2,3,-2]
Output: 3
Explanation: Subarray [3] has maximum sum 3.
```

**Example 2:**

```
Input: nums = [5,-3,5]
Output: 10
Explanation: Subarray [5,5] has maximum sum 5 + 5 = 10.
```

**Example 3:**

```
Input: nums = [-3,-2,-3]
Output: -2
Explanation: Subarray [-2] has maximum sum -2.
```

**Constraints:**

 + `n == nums.length`
 + `1 <= n <= 3 * 10^4`
 + `-3 * 10^4 <= nums[i] <= 3 * 10^4`

url: https://raw.githubusercontent.com/InnoFang/algo-set/2419a7d720bea1fd6ff3b75c38342a0ace18b205/LeetCode/0918. Maximum Sum Circular Subarray/README.md

repository: InnoFang/algo-set

repo_name: InnoFang/algo-set


text:
**AU Individual Healthcare Identifier**  *[[FMM Level 0](guidance.html)]*

This identifier profile defines an Individual Healthcare Identifier - IHI [[1]](http://ns.electronichealth.net.au/id/hi/ihi/1.0/index.html){:target="_blank"} [[2]](http://meteor.aihw.gov.au/content/index.phtml/itemId/432495){:target="_blank"} in an Australian context.

#### Extensions
Extensions used in this profile:
* Identifier: IHI Status [[1]](http://hl7.org.au/fhir/StructureDefinition/ihi-status)
* Identifier: IHI Record Status [[1]](http://hl7.org.au/fhir/StructureDefinition/ihi-record-status)

#### Usage Notes

Mutiple Individual Healthcare Identifiers are supported particularly to support the recording of IHI values where the status and/or record status varies (e.g. deceased, provisional).
Individual Healthcare Identifier is defined as a 16 digit number.

**Examples**

[Patient with IHI, Medicare Number, and Health Care Card](Patient-example0.html)

[Patient with IHI and DVA Number](Patient-example1.html)

[Benedicte du Marche as a next of kin](RelatedPerson-example0.html)

[Mary Smith as a carer](RelatedPerson-example1.html)

repository: jvitrifork/au-fhir-base

repo_name: jvitrifork/au-fhir-base


text:
# .woff

item | info
--- | ---
types | [Font](../dataTypes/font.md)
formats | [WOFF](../fileFormats/woff.md)
variants |
file info | [`extension/woff`]({{fileinfo}}/woff)

repository: Dans-labs/formats

gha_language: Python

repo_name: Dans-labs/formats


text:
# Create an API Token

1. To create a Spot API Token, log on to the Spot Console. In the settings select API.

2. The Spot Console provides both permanent and temporary tokens. Select your preferred token type and click Generate Token.

3. Give your token a name and click Generate. Your access token will appear in the window.

!> Remember to keep your tokens secret. Treat them just like passwords. They act on your behalf when interacting with the API. Do not share your personal access tokens with anyone outside your organization. Do not hard-code them into your programs. Instead, use environment variables. Please contact our support if you're concerned your token has been compromised.


text:
# EyeMovement

<img src="./eyes.png" width=150>

A fun mouse cursor tracking eye animation from Week 8 of the xPro full dev course

## Run Instructions:
Copy the three files eyes.js, index.html and styles.css to the same folder on your harddrive. Then drag and drop the idex.html file onto your web browser.

## Future Developments:
I would like to implement a bit more detail like a head, hair, ears, nose, mouth and make a full mouse watching face.

## Licence:
MIT Licence arranged through the MITxPro Emeritus Full stack Dev course.


text:
---
layout: post
title: Introduction to Intra mart Accel platform
bigimg: /img/image-header/california.jpg
tags: [Intra-mart]
---

In this article, we will talk about common information about Intra mart Accel platform.

## Table of contents
- [Introduction to Intra mart Accel platform](#introduction-to-intra-mart-accel-platform)
- [The architecture of Intra mart Accel platform](#the-architecture-of-intra-mart-accel-platform)
- [IM Juggling](#im-juggling)
- [Wrapping up](#wrapping-up)

## Introduction to Intra mart Accel platform
Intra-mart is a technology platform that connects with multiple business applications to provide a common framework for process automation and workflow management.

The solution has been used across various industry domains, including insurance, public sector, financial services and retail, and is used by over 5,000 companies and 200 partners in Japan and across Asia Pacific.

In the narture of Intra mart Accel platform, it will include some parts:
- provides some modules such as Authorization, Authentication, ...
- Seasar frameworks
- TERASOLUNA Global framework - a Java framework that is configured on the Spring framework base such as dependency injection, events, resources, i18n, validation, data binding, type conversion, SpEL, AOP.

## The architecture of Intra mart Accel platform
Below is the system architecture of intra mart accel platform.

![](../img/accel-platform/iap_architecture.png)

|        Part       |                 Description             |
| ----------------- | --------------------------------------- |
| LoadBalancer      | It is an equipment to transfer connection request from client to Web server, and performs load balancing etc. Use of Load Balancer with the following functions is recommended on intra-mart: Session maintenance function by Cookie, Health check function based on HTTP response contents, Capability to add redundancy to the Load Balancer itself. |
| Web server        | Accel Platform supports Apache WebServer and IIS. In case Resin is used, it utilizes the module called Web Server Connector that is integrated into Web server. It functions as an interface between Web server and Accel Platform by sending the client request from Web server to Accel Platform on Resin, or receiving the execution result from Accel Platform and passing it to Web server. In case multiple Accel Platforms are set as the connection destination of Web Server Connector, automatic process allocation will be possible by the round-robin function. |
| WebApplicationServer | It is a server to run intra-mart Accel Platform, and it supports Resin included in intra-mart Accel Platform as standard, Oracle Weblogic Server, and IBM Websphere Application Server. intra-mart Accel Platform is placed (deployed) as WAR (Web archive) file on this Web application server. |
| intra-mart Accel Platform | This is the product we offer, which is placed (deployed) as WAR (Web Archive) file generated by IM-Juggling, and works on Web application server. |
| RDB | It is used as a save location for various master data or transaction data of intra-mart Accel Platform. intra-mart Accel Platform supports Oracle, SQLServer, DB2, and PostgresSQL as RDB products at connection destination. |
| Storage | It is used as a save location of attachment files or electronic files for various document used on intra-mart Accel Platform. By the setting of intra-mart Accel Platform, you can specify any storage location. However, if you are operating multiple Web/AP servers, it is necessary to provide a Storage Server such as NFS or CIFS, which allows the operations of the same disk area on every Web/AP server. |
| Apache Cassandra | It is an open source NoSQL server provided by ApacheFoundation. It is needed separately if IMBox is in use. (If IMBox is not used, there is no need to install Apache Cassandra server.) While Cassandra itself provides the redundancy mechanism, operations with 3 or more Cassandra units are recommended from Cassandra/IMBox specifications viewpoint, if you need redundancy and data consistency. |
| Apache Solr | It is an open source search engine provided by ApacheFoundation and used by IM-ContentsSearch. Since Apacphe Solr is also a Web application server like intra-mart, Web application server such as Resin or Jetty must be provided for the operations environment of Apache Solr. (In case IM-ContentsSearch is not used, there is no need to install Solr server.)|

## IM Juggling & WAR files
IM-Juggling is an environment building tool can perform module management and the remote management of WAR files.
This tool can be used to install new functions and apply corrections to the defects.

And then, we will need to understand about WAR files:
- It is an acronym of **Web Application Archive** file which is defined in JavaEE and various types of files necessary for the operations of Intra mart Accel platform are included. **WAR files for Intra mart Accel platform are created by IM-Juggling.**

- Various types of files necessary for the operations of Intra mart Accel platform are stored and by deploying WAR files created by IM-Juggling in Web Application Server such as Resin, and running Web Application Server, Intra mart Accel platform itself and various applications for intra mart Accel platform that are stored in the WAR files are started and can be used.

- Since WAR file would be the minimum unit of intra-mart Accel Platform product itself, number of intra-mart Accel Platform licenses are counted by the number of WAR files.

## Wrapping up
- Intra mart Accel products will contains so many war files.

Refer:

**Architecture of Accel platform**

[http://accel-archives.intra-mart.jp/2014-winter/document/iap/public_en/iap_introduction/texts/std_function/architecture.html](http://accel-archives.intra-mart.jp/2014-winter/document/iap/public_en/iap_introduction/texts/std_function/architecture.html)

**Intra mart Accel Documents**

[https://www-en.intra-mart.jp/document/library/?](https://www-en.intra-mart.jp/document/library/?)

[http://techinfo.trithucmoi.co/ja/integration-solutions-ja/tong-quan-ve-intra-mart/](http://techinfo.trithucmoi.co/ja/integration-solutions-ja/tong-quan-ve-intra-mart/)

[http://accel-archives.intra-mart.jp/2014-winter/document/iap/public_en/development/tgfw_programming_guide/texts/reference/index.html](http://accel-archives.intra-mart.jp/2014-winter/document/iap/public_en/development/tgfw_programming_guide/texts/reference/index.html)

**Standard function in Accel platform**

[http://accel-archives.intra-mart.jp/2014-winter/document/iap/public_en/iap_introduction/texts/std_function/index.html](http://accel-archives.intra-mart.jp/2014-winter/document/iap/public_en/iap_introduction/texts/std_function/index.html)

**API for modules**

[https://www.intra-mart.jp/apidoc/iap_en/index.html](https://www.intra-mart.jp/apidoc/iap_en/index.html)

**Intra mart e Builder for Accel platform**

[https://www-en.intra-mart.jp/document/library/ebuilder/public/e_builder_user_guide/index.html](https://www-en.intra-mart.jp/document/library/ebuilder/public/e_builder_user_guide/index.html)

**Database & JDBC driver**

[https://www-en.intra-mart.jp/document/library/iap/public/setup/iap_setup_guide/texts/install/common/database.html](https://www-en.intra-mart.jp/document/library/iap/public/setup/iap_setup_guide/texts/install/common/database.html)

[https://www-en.intra-mart.jp/document/library/iap/public/setup/iap_setup_guide/texts/install/common/jdbc.html](https://www-en.intra-mart.jp/document/library/iap/public/setup/iap_setup_guide/texts/install/common/jdbc.html)

**Setup Debug Server Resin**

[https://www-en.intra-mart.jp/document/library/ebuilder/public/e_builder_setup_guide/texts/environment/index.html](https://www-en.intra-mart.jp/document/library/ebuilder/public/e_builder_setup_guide/texts/environment/index.html)


text:
# Contributing

Thank you for your interest in contributing to tdameritrade!

## Reporting bugs, feature requests, etc.

To report bugs, request new features or similar, please open an issue on the Github
repository.

A good bug report includes:

- Expected behavior
- Actual behavior
- Steps to reproduce (preferably as minimal as possible)

## Minor changes, typos etc.

Minor changes can be contributed by navigating to the relevant files on the Github repository,
and clicking the "edit file" icon. By following the instructions on the page you should be able to
create a pull-request proposing your changes.

## Setting up a development environment

If you want to help resolve an issue by making some changes that are larger than that covered by the above paragraph, it is recommended that you:

- Fork the repository on Github
- Clone your fork to your computer
- Run the following commands inside the cloned repository:
  - `pip install -e .[dev]` - This will install the Python package in development
    mode.
- Validate the install by running the tests:
  - `py.test` - This command will run the Python tests.
  - `flake8 tdameritrade` - This command will run the Python linters.

Once you have such a development setup, you should:

- Make the changes you consider necessary
- Run the tests to ensure that your changes does not break anything
- If you add new code, preferably write one or more tests for checking that your code works as expected.
- Commit your changes and publish the branch to your github repo.
- Open a pull-request (PR) back to the main repo on Github.

repository: timkpaine/tdameritrade

repo_name: timkpaine/tdameritrade


text:
OpenCanary Correlator
=======================
Thinkst Applied Research

Overview
--------
OpenCanary Correlator collects events from OpenCanary daemons and coalesces them. It sends alerts via email and sms

Prerequisites
-------------
* Redis
* Python 2.7
* Mandrill API keys for email
* Twillio API keys for sms

On Ubuntu install the following:

```$ sudo apt-get install redis-server libffi-dev python-dev```

Install
-----------------
* Create a virtualenv

```
$ virtualenv env
$ source env/bin/activate
```

* Install via pip, or

```
$ pip install opencanary-correlator
```

* Install from source

```
$ git clone https://github.com/thinkst/opencanary-correlator
$ cd opencanary-correlator
$ python setup.py install
```

Run
---------------

* Start Redis
* Locate the installed template config file, by running the correlator without any arguments

```
$ opencanary-correlator
Warning: no config file specified. Using the template config (which does not have any alerting configured):
/path/to/template/opencanary_correlator.conf
$ cp /path/to/template/opencanary_correlator.conf ./
```

* Edit the config file to add API keys, email address and/or phone numbers for alerts
* Run the correlator with saved config file

```
opencanary-correlator --config=./opencanary_correlator.conf
```

* Configure instances of opencanaryd to send events to the correlator.

repository: paradoxicalsphere/opencanary-correlator

repo_name: paradoxicalsphere/opencanary-correlator


text:
# KGMC-Results

KGMC, Lucknow - Results

    This Website gives the Mark Statement of the student upon entering Roll Number. But, this does not provide the Rank Sheet ( containing the rank secured by each student).

    So, I have create a Spider (ranker1.py - Scrapy + Splash), which can scrape each student's aggregate marks, and computes total aggregate.

    I also create a Spider (ranker2.py - Scrapy + Selenium), which can also scrape each student's aggregate marks, and computes total aggregate.

    Whichever is convenient, go for it.

To get Output

Open Command Prompt in the Root directory of the Project folder. Use following commands, get the output in the desired format :-

    For JSON format - scrapy crawl <var>SPIDER_NAME(ranker1 or ranker2)</var> -o dataset_json.json

    For CSV format - scrapy crawl <var>SPIDER_NAME(ranker1 or ranker2)</var> -o dataset_csv.csv

NOTE :

To execute above command, you should have Scrapy and Splash or Selenium installed.


text:
# Devrant-Dialogue
Unofficial CLI for Devrant

### Or... I have an API

Send a POST request to [https://api.teganburns.com/devrant/](https://api.teganburns.com/devrant/) and it should be pretty easy to figure out from there.

__Notice:__
If for any reason [DFoxinator](https://github.com/DFoxinator) requests that the api be shutdown I will do so without hesitation. So don't abuse this shit...

repository: teganburns/Devrant-Dialogue

repo_name: teganburns/Devrant-Dialogue


text:
## Only throw exceptions in exceptional circumstances

- **Exceptional**: the database went down. This is exceptional because in general we expect databases to stay up.
- **Not exceptional**: the user entered an incorrect password. This is not exceptional because users are expected to typo their password at least 23 times a day.
- Or, to put it another way, do not use exceptions for control flow. When used like this, they are effectively `GOTO` statements and make the code harder to read.

### Don't

```c#
try
{
    _authenticationService.LogUserIn(username, password);
}
catch (InvalidCredentialsException)
{
    // show "Invalid credentials" message
}
```

### Do

```c#
var authResult = _authenticationService.LogUserIn(username, password);
// instead of using an exception to indicate (expected) failure, we use a control statement
if (!authResult.IsAuthenticated)
{
    // show "Invalid credentials" message
}
```


text:
Create the image (once):

     ./do build                # build the image

Create a container from the image

     vi ./docker-compose.yml   # modify the path of your local source directory in docker-compose.yml
     ./do up                   # craete a container from the image an start it

Work with the conatiner:

     ./do stop
     ./do start
     ./do login                # jump in to the container
     ./do rm                   # remove the container

repository: unimock/supervisor-docker

repo_name: unimock/supervisor-docker


text:
### [CVE-2006-2253](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2006-2253)
![](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

PHP remote file inclusion vulnerability in visible_count_inc.php in Statit 4 (060207) allows remote attackers to execute arbitrary PHP code via a URL in the statitpath parameter.

### POC

#### Reference
- https://www.exploit-db.com/exploits/1752

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

repository: trickest/cve

repo_name: trickest/cve


text:
# iconset

## INSTALL

From the repo root, run this command:
```bash
sh install.sh
```

If installation is successful, the iconset help menu appears with suggested commands.

## QUICK START

### Make an icon set with icons

Basically, you can take a big icon, and make a set of smaller ones.

```bash
iconset foo.png
```

An icon set is generated by resizing the input icon tnto smaller icons.

### Make a placeholder icon set with color input

You can also create blank placeholder icons with specific colors:

Hexadecimal color input works:

```bash
iconset ff6600
```

Or:

```bash
iconset f60
```

RGB color input also works:

```bash
iconset rgb-255-55-120
```

repository: pffy/iconset

repo_name: pffy/iconset


text:
# Smalldoku

Ever wanted to run Sudoku without an Operating System? No? That's great, because now you can! Smalldoku is a standalone,
dependency free Sudoku library and application running directly on top of your firmware (as long as it is UEFI that is).

## Why would you do that?

Just because...why the hell not. Despite being challenged to create this, it gave me a lot of room to play with UEFI and
in general more or less bare metal development. It is a sometimes fun, sometimes frustrating learning experience to work
with UEFI and build applications on top of it

## Project structure

- `cmake` - Additional CMake modules
- `core-ui` - OS independent user interface implementation for Smalldoku, renders the UI
- `core` - OS independent logic library for Smalldoku, contains mostly basic Sudoku logic
- `linux-ui` X11 frontend, used for testing when you don't want to spin up an UEFI environment
- `uefi` - UEFI frontend, UEFI application which powers Smalldoku without an OS

## Not so frequently asked questions

**Q:** Is this useful in any way?

**A:** Absolutely not... HOWEVER, it can probably be taken as a reference on how to work with UEFI.

**Q:** How I can try this?

**A:** I might provide pre-built binaries at some point. For now, you can build it yourself,
       it's a standard CMake build. Installing it might be a pain depending on your firmware, so for now I recommend
       running it either inside the EDK2 UEFI Emulator or QEMU with OVMF.

**Q:** I want to add a feature/fix a bug/something, do you accept PR's?

**A:** If you have a cool idea or found a bug feel free to create a PR!

repository: Janrupf/smalldoku

repo_name: Janrupf/smalldoku


text:
# ObjectField

[![Gem Version](https://badge.fury.io/rb/object_field.svg)](http://badge.fury.io/rb/object_field)
[![Build Status](https://travis-ci.org/i2bskn/object_field.svg)](https://travis-ci.org/i2bskn/object_field)
[![Coverage Status](https://coveralls.io/repos/i2bskn/object_field/badge.png)](https://coveralls.io/r/i2bskn/object_field)
[![Code Climate](https://codeclimate.com/github/i2bskn/object_field/badges/gpa.svg)](https://codeclimate.com/github/i2bskn/object_field)
[![Dependency Status](https://gemnasium.com/i2bskn/object_field.svg)](https://gemnasium.com/i2bskn/object_field)

Support for object persistence.
Save the object to data store via instance method.

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'object_field'
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install object_field

## Usage

Include `ObjectField::Jsonizer` or `ObjectField::Serializer`.

#### Jsonizer

`.#jsonize` defines accessor of JSON field.

```ruby
class InJsonValue
  include ObjectField::Jsonizer
  attr_accessor :field1_json, :field2, :field3_json
  jsonize :field1_json, :field2
  jsonize :field3_json, as: :attributes
end
```

Setter is save the value to JSON.
Getter returns parsed value.
Name of accessor can be specified with `as` option.
It is set `field1`, `field2_as_json` if not specified.

```ruby
object = InJsonValue.new
object.field1 = [1, 2, 3]
p object.field1_json # => "[1,2,3]"
object.field1.each {|i| p i}
```

#### Serializer

`.#serialize` defines accessor of marshal data field.
Like marshal option of [redis-object](https://github.com/nateware/redis-objects).

```ruby
class InSerializedValue
  include ObjectField::Serializer
  attr_accessor :field_data
  serialize :field_data
end
```

Setter is save the serialized value.
Can not be saved, Proc object and anonymous class. (To raise TypeError)
Getter returns deserialized value.
Name of accessor can be specified with `as` option.
It is set `field` if not specified.

```
class SerializedObject; end
object = InSerializedValue.new
object.field = SerializedObject.new
p object.field.class # => SerializedObject
```

## Contributing

1. Fork it ( https://github.com/i2bskn/object_field/fork )
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create a new Pull Request