text:
# Pacer

Want to hit a specific target time in a hilly foot race?

This small python script might be helpful to you.

It reads distance and altitude data from a JSON file and outputs pdf files with detailed pacing info.

It requires python3 as well as jinja2, rubber and latex to generate the pdf files.

Still work in progress... More details soon...

For now visit [ctlp_2016](ctlp_2016) for sample outputs or [http://urupica.github.io/pacer/](http://urupica.github.io/pacer/) for a race I used the pace tables for.

repository: urupica/pacer

repo_name: urupica/pacer


text:
---
layout: post
title:      "Active Record: A Summary"
date:       2018-02-15 19:56:53 +0000
permalink:  active_record_a_summary
---

To get some additional practice with ActiveRecord -- which I was told was going to be important moving forward -- I decided to refactor my CLI project to include a database. The project turned out to be a bit more of an adventure than I was anticipating, but it was very helpful in terms of absorbing and improving my understanding of what ActiveRecord does and why it's important. I will try to summarize what I learned here.

My CLI app scrapes information about events currently going on in the Boston area. The structure of the project and its relationships are as follows:

![](http://burtonux.com/flatiron_blog/boston_events_project_structure.png)

In order to implement ActiveRecord and use a database, there were two main things that needed to happen:

![](http://burtonux.com/flatiron_blog/thing_one.png)

**Thing One: create the database and set up the tables. **

The database is created in the environment.rb file:

```
ActiveRecord::Base.establish_connection({
  :adapter => "sqlite3",
  :database => "db/boston_events.sqlite"
})
```

The database tables are created using migration files which live in the `db/migrate` folder:

![](http://burtonux.com/flatiron_blog/migration_files.png)

For categories and venues, coding the migrations is straightforward: create one column for each of the object's attributes.

```
class CreateCategories < ActiveRecord::Migration
  def change
    create_table :categories do |t|
      t.string :name
      t.string :url
    end
  end
end
```

```
class CreateVenues < ActiveRecord::Migration
  def change
    create_table :venues do |t|
      t.string :name
    end
  end
end
```

For events, which belong to categories and to venues, you also need to include columns for the foreign keys for those objects: category_id and venue_id:

```
class CreateEvents < ActiveRecord::Migration
  def change
    create_table :events do |t|
      t.string :name
      t.string :dates
      t.string :deal_url
      t.string :website_url
      t.integer :category_id
      t.integer :venue_id
    end
  end
end
```

Generally, any object that belongs to one or more other objects will have to have a foreign key column for each object it belongs to.

Once the migration files have been created, you create the tables by running: `rake db:migrate`

![](http://burtonux.com/flatiron_blog/thing_two.png)

**Thing Two: Define the models and the relationships among them**

The files that define the models and relationships are in the `lib/` folder, along with some other program files.

![](http://burtonux.com/flatiron_blog/models.png)

The files themselves look like:

```
class BostonEvents::Category < ActiveRecord::Base
  has_many :events
  has_many :venues, through: :events
end
```

```
class BostonEvents::Venue < ActiveRecord::Base
  has_many :events
  has_many :categories, through: :events
end
```

```
class BostonEvents::Event < ActiveRecord::Base
  belongs_to :category
  belongs_to :venue
end
```

These files define the relationships among the objects and may also include other methods you've written for your app that are associated with the classes.

**The Magic of ActiveRecord**

Once migrations have been run and the class models have been specified, ActiveRecord does its magic:

![](http://burtonux.com/flatiron_blog/activerecord_magic.png)

Why is this important? Well, for starters:
1. we no longer need to write raw SQL commands for many common queries
2. we no longer need to code methods (or create attr_accessors) to do things like return, modify, save, find, or create objects (CRUD actions)
3. ActiveRecord enables us to use method chaining that is semantic and transparent

**ActiveRecord Associations**

Due to a couple layers of abstraction, the [documentation for ActiveRecord Associations](https://apidock.com/rails/ActiveRecord/Associations/ClassMethods) can be challenging to wrap your head around:

![](http://burtonux.com/flatiron_blog/belongs_to_doc.png)

**Belongs to**

This page in the documentation is describing the methods that an object inherits (thanks to ActiveRecord) when its class is identified as belonging to another class. In  my example, events belong to categories, so this page describes the methods that my event objects inherit. These methods are instance methods, so they are called by prefixing the object (the instance of the belonging-to class) in the usual way, using dot notation: `this_event.<method_name>`

The word 'association' in the documentation is simply a placeholder for the "owning" objects. In my example, a particular event instance belongs to a particular category instance. Therefore, if I want to know which instance of category `this_event` belongs to, I construct the method call by replacing 'association' with 'category': `this_event.category`. Events also belong to venues, so the corresponding method call would be: `this_event.venue`. This construction should look familiar: calling `#category` is calling the Category class's getter method. Calling `#venue=` is calling the Venue class's setter method. The abstraction in the documentation can be hard to wrap your head around at first, but the functionality it describes is familiar and intuitive.

Examples:
* `this_event.category` will return the category object `this_event` belongs to
* `this_event.venue=(this_venue)` will assign `this_venue`  as the "owner" of `this_event`
* `this_event.build_category(:name => "Category Name")` will instantiate a new category with the name "Category Name" and assign it to `this_event`

![](http://burtonux.com/flatiron_blog/has_many_doc.png)

**Has many**

Similarly, when you establish a has_many relationship, the "owning" object inherits a whole bunch of instance methods from ActiveRecord. (Only the first few are shown in in the screenshot.) I find the documentation for the has_many relationship to be a little more intuitive: if an object "has many" of another object, it has a collection of them. Therefore it makes sense that the word 'collection' in the documentation stands in for the object that there are many of. As with the "belongs to" relationship, these are instance methods, and you call them by prefixing the object that "has many" of the "collection" objects. For example, calling `this_category.events` will return an array containing all the event instances that belong to `this_category`.

Note that ActiveRecord also establishes conventions that are semantic: my class names are Category and Event, but I query the events that belong to a category instance using the plural form: `this_category.events`. This is because, by defining the has_many relationship in the model, I told ActiveRecord that there are many of them.

As mentioned above, there are a lot more methods that you get for free when you establish a "has many" association; they are described in detail [in the documentation](https://apidock.com/rails/v4.2.7/ActiveRecord/Associations/ClassMethods/has_many).

To close, I'm going to talk a little about two particularly cool features that ActiveRecord provides.

**#1 Join Models**

My app also contained a couple of join -- or "has many through" -- relationships. Categories have many events, and events belong to venues, so categories have many venues through events (and vice versa). Because of the magic of ActiveRecord, you don't need to do an explicit join a la SQL, and you don't need to "go through" the events they share. In other words, this works: `this_category.venues`. ActiveRecord has told my program that it needs to first find all the events associated with `this_category` using the events' category_id foreign key, then find all the venues associated with those events, this time using the events' venue_id foreign key, and return them. For comparison, the corresponding SQL query is*:

```
SELECT  "venues".* FROM "venues" INNER JOIN "events" ON "venues"."id" = "events"."venue_id" WHERE "events"."category_id" = ? LIMIT ?  [["category_id", 283], ["LIMIT", 11]]
```

Nice, no?

**#2 Method Chaining**

ActiveRecord also enables method chaining: the program knows how everything is tied together, so you can do things like: `this_category.events.first.venue.name`, which will return the name of the venue associated with the first event that belongs to the category. Or `this_venue.sponsors.find_by(:name => "Sponsor Name").events`, which will find a particular sponsor associated with the venue and return all the events belonging to that sponsor. (Sponsors are making a surprise appearance here: they were in my project but I left them out of the descriptions above to simplify things.) Or `this_venue.events.each{ |event| puts "#{event.name}, #{event.dates}"}`, which puts out a list of all the events happening at a particular venue, along with the dates they're happening.

Chained methods make for efficient code plus they're semantic and intuitive which makes them a lot of fun to use. After I finished refactoring my project, I got into the console and played around for a while. It was mainly to make sure the examples I give in this post really work, but it was also just playing. I recommend it both as a learning experience and as entertainment.

*you can see the SQL corresponding to any ActiveRecord query by adding this line to the console file: `ActiveRecord::Base.logger = Logger.new(STDOUT)`. I learned how from [this Avi video](https://youtu.be/ZfJ1rqFcNFU).

branch_name: refs/heads/master

extension: markdown

license_type: permissive


text:
title: Overview
---

Quasar Apps are made of high-level building blocks called components. Components allow you to quickly construct an interface for your App. Quasar comes with a number of components, including modals, action sheets, collapsibles, cards, dialogs, FAB, lists and many more.

Quasar Components are written as Web Components, so they embed HTML, CSS and Javascript code that you can use by just including an HTML tag in your Page and Layout templates.

> **IMPORTANT**
> For Vue & Quasar developers (beginners or not), read [Introduction for Beginners](/components/introduction-for-beginners.html) first. It's mandatory in order to understand how you can use Vue properties, methods and so on.

Check out the examples (text and live demos for each platform) to see what each component looks like and to learn how to use each one.

[Live Component Demo: Material Theme)](http://quasar-framework.org/quasar-play/android/index.html#/showcase)

[Live Components Demo: iOS Theme)](http://quasar-framework.org/quasar-play/apple/index.html#/showcase)

license: MIT

branch_name: refs/heads/dev

extension: md


text:
<!--

 Licensed to the Apache Software Foundation (ASF) under one
 or more contributor license agreements.  See the NOTICE file
 distributed with this work for additional information
 regarding copyright ownership.  The ASF licenses this file
 to you under the Apache License, Version 2.0 (the
 "License"); you may not use this file except in compliance
 with the License.  You may obtain a copy of the License at

 http://www.apache.org/licenses/LICENSE-2.0

 Unless required by applicable law or agreed to in writing,
 software distributed under the License is distributed on an
 "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 KIND, either express or implied.  See the License for the
 specific language governing permissions and limitations
 under the License.

-->

# JavaScript Gremlin Language Variant

[Apache TinkerPop™][tk] is a graph computing framework for both graph databases (OLTP) and graph analytic systems
(OLAP). [Gremlin][gremlin] is the graph traversal language of TinkerPop. It can be described as a functional,
data-flow language that enables users to succinctly express complex traversals on (or queries of) their application's
property graph.

Gremlin-Javascript implements Gremlin within the JavaScript language and can be used on Node.js.

```bash
npm install gremlin
```

Gremlin-Javascript is designed to connect to a "server" that is hosting a TinkerPop-enabled graph system. That "server"
could be [Gremlin Server][gs] or a [remote Gremlin provider][rgp] that exposes protocols by which Gremlin-Javascript
can connect.

A typical connection to a server running on "localhost" that supports the Gremlin Server protocol using websockets
looks like this:

```javascript
const gremlin = require('gremlin');
const traversal = gremlin.process.AnonymousTraversalSource.traversal;
const DriverRemoteConnection = gremlin.driver.DriverRemoteConnection;

const g = traversal().withRemote(new DriverRemoteConnection('ws://localhost:8182/gremlin'));
```

Once "g" has been created using a connection, it is then possible to start writing Gremlin traversals to query the
remote graph:

```javascript
g.V().hasLabel('person').values('name').toList()
  .then(names => console.log(names));

const names = await g.V().hasLabel('person').values('name').toList();
console.log(names);
```

# Sample Traversals

The Gremlin language allows users to write highly expressive graph traversals and has a broad list of functions that
cover a wide body of features. The [Reference Documentation][steps] describes these functions and other aspects of the
TinkerPop ecosystem including some specifics on [Gremlin in Javascript][docs] itself. Most of the examples found in the
documentation use Groovy language syntax in the [Gremlin Console][console]. For the most part, these examples
should generally translate to Javascript with [little modification][differences]. Given the strong correspondence
between canonical Gremlin in Java and its variants like Javascript, there is a limited amount of Javascript-specific
documentation and examples. This strong correspondence among variants ensures that the general Gremlin reference
documentation is applicable to all variants and that users moving between development languages can easily adopt the
Gremlin variant for that language.

## Create Vertex

```javascript
/* if we want to assign our own ID and properties to this vertex */
const { t: { id } } = gremlin.process;
const { cardinality: { single } } = gremlin.process;

/**
 * Create a new vertex with Id, Label and properties
 * @param {String,Number} vertexId Vertex Id (assuming the graph database allows id assignment)
 * @param {String} vlabel Vertex Label
 */
const createVertex = async (vertexId, vlabel) => {
  const vertex = await g.addV(vlabel)
    .property(id, vertexId)
    .property(single, 'name', 'Apache')
    .property('lastname', 'Tinkerpop') // default database cardinality
    .next();

  return vertex.value;
};
```

## Find Vertices

```javascript
/**
 * List all vertexes in db
 * @param {Number} limit
 */
const listAll = async (limit = 500) => {
  return g.V().limit(limit).elementMap().toList();
};
/**
 * Find unique vertex with id
 * @param {Object} vertexId Vertex Id
 */
const findVertex = async (vertexId) => {
  const vertex = await g.V(vertexId).elementMap().next();
  return vertex.value;
};
/**
 * Find vertices by label and 'name' property
 * @param {String} vlabel Vertex label
 * @param {String} name value of 'name' property
 */
const listByLabelAndName = async (vlabel, name) => {
  return g.V().has(vlabel, 'name', name).elementMap().toList();
};
```

## Update Vertex
```javascript
const { cardinality: { single } } = gremlin.process;

/**
 * Update Vertex Properties
 * @param {String,Number} vertexId Vertex Id
 * @param {String} name Vertex Name Property
 */
const updateVertex = async (vertexId, label, name) => {
  const vertex = await g.V(vertexId).property(single, 'name', name).next();
  return vertex.value;
};
```

__NOTE__ that versions suffixed with "-rc" are considered release candidates (i.e. pre-alpha, alpha, beta, etc.) and thus
for early testing purposes only. These releases are not suitable for production.

[tk]: https://tinkerpop.apache.org
[gremlin]: https://tinkerpop.apache.org/gremlin.html
[docs]: https://tinkerpop.apache.org/docs/current/reference/#gremlin-javascript
[gs]: https://tinkerpop.apache.org/docs/current/reference/#gremlin-server
[rgp]: https://tinkerpop.apache.org/docs/current/reference/#connecting-rgp
[console]: https://tinkerpop.apache.org/docs/current/tutorials/the-gremlin-console/
[steps]: https://tinkerpop.apache.org/docs/current/reference/#graph-traversal-steps
[differences]: https://tinkerpop.apache.org/docs/current/reference/#gremlin-javascript-differences

repository: apache/tinkerpop

gha_language: Java

repo_name: apache/tinkerpop


text:
# Full Stack Personal Finance Web App

This is a personal finance application that allows users to link their bank account via the Plaid API. Current functionality includes basic authentication via JSON Web Token, and the addition, deletion, and refreshing of a bank account. The application will display the user's account balances and transactions. Note that this project is a work in progress - more features are planned to be implemented in the future.

## Setup

1. `git clone https://github.com/jagodin/personal-finance-app`
2. `cd personal-finance-app`
3. `npm install`
4. `npm run dev` to run the development environment.

Obtain your Plaid API keys from [here](https://dashboard.plaid.com/signup) and set up a [MongoDB database](https://www.mongodb.com/download-center)

Configure `./config/default.json`

```
{
    "mongoURI": "YOUR_MONGO_URI",
    "jwtSecret": "YOUR_SECRET_TOKEN"
}
```

## Technologies

1. Node.js
2. React
3. Redux
4. MongoDB
5. Express.js
6. Material UI

## Packages

1. Axios
2. Express Validator
3. JSON Web Token
4. Redux Thunk
5. Bcrypt.js
6. Mongoose

## Screenshots

Login/Registration Page
![Login/Registration Page](https://user-images.githubusercontent.com/17988743/72691879-98e91780-3af6-11ea-8125-c8e25a172663.JPG)

Dashboard and Profile Menu
![Dashboard and Profile Menu](https://user-images.githubusercontent.com/17988743/72690028-09d40380-3ae6-11ea-8478-9d65f0d08dcb.JPG)

Linked Accounts and Balances
![Linked Accounts and Balances](https://user-images.githubusercontent.com/17988743/72690034-26703b80-3ae6-11ea-8d82-cd152aeba8f7.JPG)

Transactions
![Transactions](https://user-images.githubusercontent.com/17988743/72690047-3e47bf80-3ae6-11ea-920e-23ef0e32081e.JPG)

Plaid Link
![Plaid Link](https://user-images.githubusercontent.com/17988743/72690044-2e2fe000-3ae6-11ea-8592-563974a0230a.JPG)

Responsive Dashboard
![Responsive Dashboard](https://user-images.githubusercontent.com/17988743/72690045-3556ee00-3ae6-11ea-861d-b6ca09cffb90.JPG)

## Future Enhancements

1. Implement budgets and categorize transactions into appropriate budget.
2. Add user settings (i.e. UI preferances).
3. Give users the ability to report application issues via the Support page.
4. Implement FAQ.
5. Responsive UI enhancements.
6. Implement cache to prevent user's from overloading the backend and Plaid API.
7. Implement Google Firebase Authentication.

## Disclaimer

Note that the application exposes the user's `access_tokens` and `item_ids` to the client. For production releases, these must be securely persisted to your database and never exposed to the client.

From the Plaid API documentation:

> access_tokens and item_ids are the core identifiers that map your end-users to their financial institutions. You should persist these securely and associate them with users of your application. Make sure, however, that these identifiers are never exposed client-side. Keep in mind that one user can create multiple Items if they have accounts with multiple financial institutions.

repository: jagodin/personal-finance-app

gha_language: JavaScript

gha_license_id: MIT

repo_name: jagodin/personal-finance-app


text:
---
layout: default
---

# 1995-11-24 - Re: real life problems with ITAR (was Spam the Sign!)

## Header Data

From<EMAIL_ADDRESS>(jim bell)

To: attila<EMAIL_ADDRESS>Message Hash: f3fdaaab621d4c680ef99894c941971cd2032da6368ecaf1f2a3fb13402a9225

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1995-11-24 17:41:00 UTC

Raw Date: Sat, 25 Nov 1995 01:41:00 +0800

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(jim bell)
Date: Sat, 25 Nov 1995 01:41:00 +0800
To: attila<EMAIL_ADDRESS>Subject: Re: real life problems with ITAR (was Spam the Sign!)
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

<EMAIL_ADDRESS>said:

>   On Thu, 23 Nov 1995, jim bell wrote:
>
>> I very much agree with the direction you appear to be headed in.  It seems
>> to me that Netscape should have no problem devising some sort of scenario in
>> which such a program eventually gets onto the nets, but in a way that is
>> squeaky clean, at least for THEM.
>>
>>
>> In addition, why should they even need to write the encrytion part of their
>> software IN the US?  It occurs to me that one way to do this might be to
>> send one of their programmers to a conveniently-located place, such as
>> Vancouver BC , Montreal Canada, or a few other nearby places, with a great
>> deal of fanfare, and tell him to "write some crypto."  He does, and brings
>> it back into the US with him, leaving a copy of it "outside" the country for
>> international distribution.
>>
>    <attila sez>  I think they have that one covered --not only is it
>violation of ITAR's intent to send a programmer out of the U.S.

Well, don't assume that because something's a "violation of ITAR's INTENT"
it is actually a violation of ITAR.    It can't be assumed that ITAR is
_perfect_:  That it actually prohibits every activity the government that
wrote it didn't like.

, but is
>illegal to hire a foreign national to program for your non-U.S. products.

Sure about this?!?

>    the test is going to be with someone like Sun who "bought" a group of
>Russian crypto programmers and left them in Russia.  Now, the problem
>with ITAR is that if you import that code, you can not then export the
>code since it is now covered by ITAR.

I didn't say that the code would ever be "re-exported":  A copy would be
brought into the US for domestic use, and everyone else outside the border
would get their own copy from an outside server.

>    secondly, it appears there is a move afoot to make it an ITAR
>violation to hire the foreign nationals to circumvent ITAR --basically,
>the Feds want to stop cryptography _everywhere_, including telling
>Russians they can not work for U.S. companies!  Just where do they think
>they are getting off?

It is for this kind of problem that I "invented" my concept of
"Assassination Politics":  If everybody pissed off at this situation was
willing to donate $10 to a fund to reward the deaths of a few government
officials responsible for ITAR, I can well imagine that this would shake
them up a bit.

{% endraw %}
```

## Thread

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

+ Return to "[attila <attila@primenet.com>](/authors/attila_attila_at_primenet_com_)"
+ Return to<EMAIL_ADDRESS>(jim bell)](/authors/jimbell_at_pacifier_com_jim_bell_)"

+ 1995-11-24 (Sat, 25 Nov 1995 01:41:00 +0800) - Re: real life problems with ITAR (was Spam the Sign!) -<EMAIL_ADDRESS>(jim bell)_
  + 1995-11-25 (Sat, 25 Nov 1995 09:31:24 +0800) - [Re: real life problems with ITAR (was Spam the Sign!)](/archive/1995/11/af7259b32391936f5370a6c659f636d6f63b5d2c68e5641959f105ba2b5b7788) - _attila<EMAIL_ADDRESS>


text:
---
layout: post
title: "White Fang"
description: "Jack London's immortal tale of courage and survival comes to life amid the breathtaking beauty of the great Alaskan frontier. Ethan Hawke stars as a young man trying to fulfill his father's dying wish to find gold in the treacherous Yukon valley. His incredible Journey begins when he meets a veteran gold miner who guides young Jack to his father's claim. Along the way, Jack discovers a kindred spirit who will change his life forever a magnificent wolf-dog named White Fang. From the taming of a wolf, to the taming of the wild, he must find the courage to con.."
img: 0103247.jpg
kind: movie
genres: [Adventure,Drama]
tags: Adventure Drama
year: 1991
imdb_rating: 6.7
votes: 19150
imdb_id: 0103247
netflix_id: 80245121
color: 8d99ae
---
Director: `Randal Kleiser`

Cast: `Jed` `Klaus Maria Brandauer` `Ethan Hawke` `Seymour Cassel` `Susan Hogan`

Jack Conroy is a young gold hunter, who seeks gold in the enormous and the snowy deserts of Alaska. One day, he saved a mixed dog-wolf from the hands of a cruel man, and a brave friendship develops between the two. The dog-wolf, who is named "the white fang" for it's sharp and white teeth, was left alone after his mother was killed by a hunter. After a while, the white fang was taken from Jack, by a man who put him in an illegal dog fighting pen to fight other dogs. White Fang becomes a professional, experienced and a cruel killer. But unexpectedly after a long time Jack meets him again and they renew their friendship. When a group of criminals wants to steal Jack's gold, White Fang is the only one who can help him to fight them off.::rsilberman

repository: meparth/BongNetflix

repo_name: meparth/BongNetflix


text:
# T9107_SW1000 Software Delivery Server

This repo contains the sourcecode of the luetze sofware delivery system.
The system uses the python django web framework to provide a human readable
website as well as a machine readable rest api.

## Interfaces

The LSD system shall be accessible via a rest api to register new builds during
the ci pipeline run.

The LSD system shall be accessible via a standard web browser to access the
build results and software documentation.

The LSD system shall be accessible via a rest api to download software binaries
to the production systems during manufacturing.

### Requirements

Install the following requirements (should work on an Ubuntu 18.04 system)

Python 3.x
```
sudo apt-get install python3 python3-venv python3-pip
```

Python Virtualenvwrapper
```
python3 -m pip install virtualenvwrapper
```
Add shell extensions to your .bashrc
```
export VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3
. /home/<your username>/.local/bin/virtualenvwrapper.sh
```

For python-ldap authentication OpenLDAP is needed:
```
sudo apt-get install -y python-dev libldap2-dev libsasl2-dev libssl-dev
```

For the postgresql server (used as production database + needed to install python requirements):
```
sudo sudo apt-get install postgresql postgresql-contrib libpq-dev
```

Generate a new virtual environment using:
```
mkvirtualenv -p python3 t9107_sw1000_lsd
```

And switch to this Venv to work on it:
```
workon t9107_sw1000_lsd
```

The correct setup of all required Packages is acomplished by pip-tools, to install it run the following command in your venv:
```
python -m pip install pip-tools
```

all required python packets can be installed using:
```
pip-compile
pip-sync
```

### credentials
The passwords and the django secret key are held by a json file outside of this repository.
The file needs to be in the same directory as the repository.
The filename has to be ``config.json``
The file has to provide these variables:
```
{
    "lsd_secret_key": "<django secret key - used for security features>",
    "lsd_dbpass": "<password of the db or "" in case of internal sqlite db>",
    "lsd_ldappass": "<password of the luetze ldap user<EMAIL_ADDRESS>    "lsd_testserver": true/false, (optional - true: django uses an internal sqlite db - for test/develop purpose)
    "lsd_debug": true/false (optional - if not set it will be set through the lsd_testserver)
}
```

If this file is not found the LSD defaults to testserver state without LDAP
access and uses the internal sqlite dummy database.

### database

The productive LSD system uses a postgres sql database.
A postgresql database has to be setup with name 'lsd' and a user named 'lsd'

#### Database setup:

Create user and databse
```
sudo su - postgres
createuser -P lsd
createdb -O lsd lsd
exit
```

Export and import data
```
# create dump
pg_dump -C -h localhost -U lsd lsd > lsd.dump

# apply dump
psql -h localhost -U lsd lsd < lsd.dump
```

The password of the lsd user must match the one configured in the config.json
file

If you want to setup a test instance the included sqlite database will be used.

### static files

Django needs some static files to be provided to the client.
In the current implementation all software and documentation is provided as
static files as well.

The static files are kept in the single django apps in this repository.
For production systems they have to be copied and held on the system.

run:
```
sudo python djangoProject/manage.py collectstatic
```

This will collect all static files in the repository and merges it with the
static files on the file system of the production machine.

When a file needs to be accesed, make sure to access the path like:
    cur_dir = os.path.dirname(__file__)
    path    = os.path.join(cur_dir, "../media/"+name_of_file)

## Usage

### Running the server

Start Django

Start a Shell at the top level of the repository:

```
python manage.py runserver 0:8080
```

Now you can access the running LSD server(or testserver) by connecting with a
browser of your choice.

### Testserver admin credentials:

You can access the admin console of the Testserver with at /admin with the
following credentials.

```
username: admin
pw:       1234
```

### Debugging the server

The repository comes with .vscode directory specifying a simple debug
configuration.
Just open the repository as directory in vscode and hit F5.

You need to have the python plugin installed (on both your host and your ssh target (if used)).
You have to choose the correct python interpreter first (the virtualenv).

After all that the server should start in a debug context and you can simply add
breakpoints anywhere you like.

### WSGI configuration - production server

To run the LSD (or any django app) in a production environment you can run it
as WSGI service.

See the following demo config for an apache2 webserver:

```
<VirtualHost *:80>
        ServerAdmin<EMAIL_ADDRESS>        ServerName software.luetze.int
        ServerAlias www.software.luetze.int

        Redirect permanent / https://software.luetze.int/
</VirtualHost>

<VirtualHost *:443>
        # The ServerName directive sets the request scheme, hostname and port that
        # the server uses to identify itself. This is used when creating
        # redirection URLs. In the context of virtual hosts, the ServerName
        # specifies what hostname must appear in the request's Host: header to
        # match this virtual host. For the default virtual host (this file) this
        # value is not decisive as it is used as a last resort host regardless.
        # However, you must set it for any further virtual host explicitly.
        #ServerName www.example.com

        ServerAdmin<EMAIL_ADDRESS>        ServerName software.luetze.int
        ServerAlias www.software.luetze.int

        SSLEngine on
        SSLCertificateFile      /etc/apache2/sw_int_ssl_certs/sw.luetze.int.crt
        SSLCertificateKeyFile   /etc/apache2/sw_int_ssl_certs/sw.luetze.int.key
        SSLCertificateChainFile /etc/apache2/sw_int_ssl_certs/DE-CA-01-CA.pem

        # Available loglevels: trace8, ..., trace1, debug, info, notice, warn,
        # error, crit, alert, emerg.
        # It is also possible to configure the loglevel for particular
        # modules, e.g.
        #LogLevel info ssl:warn

        ErrorLog ${APACHE_LOG_DIR}/error.log
        CustomLog ${APACHE_LOG_DIR}/access.log combined

        # For most configuration files from conf-available/, which are
        # enabled or disabled at a global level, it is possible to
        # include a line for only one particular virtual host. For example the
        # following line enables the CGI configuration for this host only
        # after it has been globally disabled with "a2disconf".
        #Include conf-available/serve-cgi-bin.conf

        Alias /static /var/lsd/static
        <Directory /var/lsd/static>
                Require all granted
        </Directory>

        <Directory /home/stefan/gitRepos/T9107/t9107_sw1000_lsd/djangoProject/djangoProject>
                <Files wsgi.py>
                        Require all granted
                </Files>
        </Directory>

        WSGIScriptAlias / /home/stefan/gitRepos/T9107/t9107_sw1000_lsd/djangoProject/djangoProject/wsgi.py
        WSGIDaemonProcess lsd_app python-path=/home/stefan/gitRepos/T9107/t9107_sw1000_lsd/djangoProject python-home=/home/stefan/.virtualenvs/t910$
        WSGIProcessGroup lsd_app

</VirtualHost>
```

Please mind:

- grant access to the static directory (STATIC_ROOT from settings.py file)
- grant access to wsgi file
- setup WSGI config (look into apache2 documentation for more information)

The rest is ssl and some basic config.
Please look into the apache2 documentation for more information.

### Testing

Tests are written for each module and stored in the corresponding tests module.
Tests are executed using the following command:

./djangoProject/manage.py test djangoProject

To test just one specific application specify the application in question:

./djangoProject/manage.py test <aplicationname>

## Documentation

This project is documented using the LBS Sphinx integration.
To rebuild the documentation just run:

```
# build html and pdf
make all

# build only html
make sphinx_html

# build only pdf
make sphinx_pdf

# run the sphinx autobuilder (rebuilds on every detected code change)
make sphinx_autobuilder
```

If you have troubles building the documentation please ensure:

1. is the lbs submodule checked out (git submodule init && git submodule update)
2. are the lbs python requirements installed (requirements txt insit the lbs)
3. is your lbs environment setup correctly

repository: praktianerJones/LSD

branch_name: refs/heads/main

repo_name: praktianerJones/LSD


text:
All pull requests that respect next rules are welcome:

- Before opening pull request to this repo run `npm t` to run tests.
- All bugfixes and features should contain tests and coverage must be 100%

repository: iamolegga/nestjs-session

gha_language: TypeScript

repo_name: iamolegga/nestjs-session


text:
# vuemarket

> Fantastic Vue Components and Libraries.

[![Build Status](https://travis-ci.org/sinchang/vuemarket.svg?branch=master)](https://travis-ci.org/sinchang/vuemarket)

## Submitting new libraries and components

Fork this repository, add your libraries or components to "data.js" and submit a pull request.

### Rules
  * Must have demo
  * Must have star over 50

## Contributing

1. Fork it!
2. Create your feature branch: `git checkout -b my-new-feature`
3.  Push to the branch: `git push origin my-new-feature`
5. Submit a pull request :D

## Development

- `npm run dev`: Run in development mode

Check out your npm scripts, it's using [poi](https://github.com/egoist/poi) under the hood.

---

Generated by [create-vue-app](https://github.com/egoist/create-vue-app)

## Author

**vuemarket** © [sinchang](https://github.com/sinchang), Released under the [MIT](./LICENSE) License.<br>
Authored and maintained by sinchang with help from contributors ([list](https://github.com/sinchang/vuemarket/contributors)).

> [sinchang.me](https://sinchang.me) · GitHub [@sinchang](https://github.com/sinchang) · Twitter [@sinchangwen](https://twitter.com/sinchangwen)

repository: sinchang/vuemarket

repo_name: sinchang/vuemarket


text:
# DynamoDb CRUD with vogels

## Setup for AWS
- create a `.env` with the following key value pair
```
DYNAMODB_ACCESSKEYID = your-access-key
DYNAMODB_SECRETACCESSKEY = your-secret-access-key
DYNAMODB_REGION = us-east-1
```

## Setup for local
- Install [Docker](https://www.docker.com/)
- run `docker-compose up` in a new terminal to start up a local dynamo db

## Run the app
- run `npm i` in the project root to install npm packages
- run `npm start` to start the service
- navigate to [http://localhost:3000](http://localhost:3000) to create the user table for the first time
- navigate to [http://localhost:3000/users](http://localhost:3000/users) to view all users
- POST, PUT and DELETE to create, update or delete user(s) use [Postman](http://www.getpostman.com/) to make your life easier

this is a fork from: https://github.com/deepaksisodiya/CRUD-APIs-Using-Koajs-Vogels-Dynamodb


text:
# manifestservice
https://github.com/uc-cdis/manifestservice

Microservice that's responsible for creating and retrieving files from a dedicated s3 bucket.
See repo for more information.

## Deployment

Run
```
gen3 kube-setup-manifestservice
gen3 kube-setup-certs
gen3 kube-setup-networkpolicy
gen3 kube-setup-revproxy
```
Or just `gen3 roll all`

repository: uc-cdis/cloud-automation

gha_language: Shell

repo_name: uc-cdis/cloud-automation


text:
---
layout: post
title: "Announcing the release of Finatra 2.0.1!"
date: 2015-09-21 16:04:20 -0700
comments: false
categories: ["blog", "releases"]
author: scosenza
---

#### We're pleased to announce the [release](https://github.com/twitter/finatra/releases/tag/v2.0.1) of Finatra 2.0.1!

You can download the release from [Maven Central][maven-central].

For a full list of changes and updates see the diff [here](https://github.com/twitter/finatra/compare/v2.0.0...v2.0.1).

See the Finatra [Github page](https://github.com/twitter/finatra) for more information on getting started.

-- The [Finatra](https://groups.google.com/forum/#!forum/finatra-users) Team

[maven-central]: http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22com.twitter.finatra%22%20AND%20v%3A%222.0.1%22

repository: apakulov/finatra

branch_name: refs/heads/develop

repo_name: apakulov/finatra


text:
# ![nf-core/gwas](docs/images/nf-core-gwas_logo.png)

**This is a new skeleton pipeline**.

[![GitHub Actions CI Status](https://github.com/nf-core/gwas/workflows/nf-core%20CI/badge.svg)](https://github.com/nf-core/gwas/actions)
[![GitHub Actions Linting Status](https://github.com/nf-core/gwas/workflows/nf-core%20linting/badge.svg)](https://github.com/nf-core/gwas/actions)
[![Nextflow](https://img.shields.io/badge/nextflow-%E2%89%A520.04.0-brightgreen.svg)](https://www.nextflow.io/)

[![install with bioconda](https://img.shields.io/badge/install%20with-bioconda-brightgreen.svg)](https://bioconda.github.io/)
[![Docker](https://img.shields.io/docker/automated/nfcore/gwas.svg)](https://hub.docker.com/r/nfcore/gwas)
[![Get help on Slack](http://img.shields.io/badge/slack-nf--core%20%23gwas-4A154B?logo=slack)](https://nfcore.slack.com/channels/gwas)

## Introduction

The pipeline is built using [Nextflow](https://www.nextflow.io), a workflow tool to run tasks across multiple compute infrastructures in a very portable manner. It comes with docker containers making installation trivial and results highly reproducible.

## Quick Start

1. Install [`nextflow`](https://nf-co.re/usage/installation)

2. Install any of [`Docker`](https://docs.docker.com/engine/installation/), [`Singularity`](https://www.sylabs.io/guides/3.0/user-guide/) or [`Podman`](https://podman.io/) for full pipeline reproducibility _(please only use [`Conda`](https://conda.io/miniconda.html) as a last resort; see [docs](https://nf-co.re/usage/configuration#basic-configuration-profiles))_

3. Download the pipeline and test it on a minimal dataset with a single command:

    ```bash
    nextflow run nf-core/gwas -profile test,<docker/singularity/podman/conda/institute>
    ```

    > Please check [nf-core/configs](https://github.com/nf-core/configs#documentation) to see if a custom config file to run nf-core pipelines already exists for your Institute. If so, you can simply use `-profile <institute>` in your command. This will enable either `docker` or `singularity` and set the appropriate execution settings for your local compute environment.

4. Start running your own analysis!

    <!-- TODO nf-core: Update the example "typical command" below used to run the pipeline -->

    ```bash
    nextflow run nf-core/gwas -profile <docker/singularity/podman/conda/institute> --input samplesheet.csv --genome GRCh37
    ```

See [usage docs](https://nf-co.re/gwas/usage) for all of the available options when running the pipeline.

## Documentation

The nf-core/gwas pipeline comes with documentation about the pipeline: [usage](https://nf-co.re/gwas/usage) and [output](https://nf-co.re/gwas/output).

<!-- TODO nf-core: Add a brief overview of what the pipeline does and how it works -->

<!-- From Raquel Genomics imputaiton pipeline-->

A tool for imputation of genotype array datasets from dbGaP. The Genotype Imputation Pipeline consists of the following steps:

0. Identify input genome build version automatically
1. Lift the input to build GRCh37 (hg19)
2. Quality control 1: LD-based fix of strand flips, fix strand swaps, filter variants by missingness
3. Split samples by ancestry
4. Quality control 2: filter samples by missingness, filter variants by HWE
5. Phase
6. Impute

## Dependencies
The pipeline was tested in garibaldi using the following required software and packages:

- R v3.5.1
- vcftools v0.1.14
- PLINK v1.9
- PLINK v2.00a3LM 64-bit Intel
- samtools v1.9
- GenotypeHarmonizer v1.4.20
- ADMIXTURE
- Eagle v2.4
- Minimac4
- liftOver

## How to run

### Step 0: Check genome build and select chain file

Where:
- myinput is the full path to the input genotype array dataset in either vcf or vcf.gz format
- myoutput is the full path to save the output of this step
- gz (gz=yes or gz=no) is whether the input file is either vcf or vcf.gz format

The output file will have the sufix *.BuildChecked

### Step 1: Lifeover input genotype array to GRCh37 build

### Step 2: LD-based fix of strand flips, fix strand swaps and mismatching alleles, and initial quality control (90% missingnes per variant)

### Step 3: Estimate ancestry and split samples by ancestry

### Step 4: 2nd quality control

### Step 5: Phasing

### Step 6: Imputation and post-imputation quality control

## Credits

nf-core/gwas was originally written by Abhinav Sharma, Raquel Dias, Alain Coletta.

## Contributions and Support

If you would like to contribute to this pipeline, please see the [contributing guidelines](.github/CONTRIBUTING.md).

For further information or help, don't hesitate to get in touch on the [Slack `#gwas` channel](https://nfcore.slack.com/channels/gwas) (you can join with [this invite](https://nf-co.re/join/slack)).

## Citation

<!-- TODO nf-core: Add citation for pipeline after first release. Uncomment lines below and update Zenodo doi. -->
<!-- If you use  nf-core/gwas for your analysis, please cite it using the following doi: [10.5281/zenodo.XXXXXX](https://doi.org/10.5281/zenodo.XXXXXX) -->

You can cite the `nf-core` publication as follows:

> **The nf-core framework for community-curated bioinformatics pipelines.**
>
> Philip Ewels, Alexander Peltzer, Sven Fillinger, Harshil Patel, Johannes Alneberg, Andreas Wilm, Maxime Ulysse Garcia, Paolo Di Tommaso & Sven Nahnsen.
>
> _Nat Biotechnol._ 2020 Feb 13. doi: [10.1038/s41587-020-0439-x](https://dx.doi.org/10.1038/s41587-020-0439-x).
> ReadCube: [Full Access Link](https://rdcu.be/b1GjZ)

repository: alaincoletta/gwas

repo_name: alaincoletta/gwas


text:
## 0.4.2 Release notes (25/1/2018)

- Fixes for Swift 4 `@objc` inference

## 0.4.1 Release notes (30/9/2017)

- Updated to Swift 4.0

## 0.4.0 Release notes (30/9/2017)
----

- Lowered the target OS to iOS 8.0

## 0.3.0 Release notes (22/9/2017)
----

- Mask changes are now animated

## 0.2.0 Release notes (18/9/2017)
----

- Added the ability to customise which edges are masked
- Fixed a crash which happened when on relaunching the example app

## 0.1.1 Release notes (17/9/2017)
----

- Fixed an issue where touches were being interception
- Fixed a selector crash
- Updated the ReadMe with customisation options and Apple's HIG recommendations

## 0.1.0 Release notes (16/9/2017)
----

Initial release

repository: blyscuit/NotchKit

repo_name: blyscuit/NotchKit


text:
# Mauro Data Mapper Core Backend Application

Core API for Mauro Data Mapper

| Branch | Build Status |
| ------ | ------------ |
| main | [![Build Status](https://jenkins.cs.ox.ac.uk/buildStatus/icon?job=Mauro+Data+Mapper%2Fmdm-core%2Fmain)](https://jenkins.cs.ox.ac.uk/blue/organizations/jenkins/Mauro%20Data%20Mapper%2Fmdm-core/branches) |
| develop | [![Build Status](https://jenkins.cs.ox.ac.uk/buildStatus/icon?job=Mauro+Data+Mapper%2Fmdm-core%2Fdevelop)](https://jenkins.cs.ox.ac.uk/blue/organizations/jenkins/Mauro%20Data%20Mapper%2Fmdm-core/branches) |

## Requirements

* Grails 4.0.6 +
* Gradle 6.7.1
* Java OpenJDK 12

All of the above can be installed an easily maintained by using [SDKMAN!](https://sdkman.io).

*Grails 4.0.3 will not run in any version above Java 12, and Grails 4 will not work on any version below Java 11*

* PostgreSQL 12+

This is required to run any of the sub projects in development or production mode.
In test mode they will use an in-memory H2 database.

## Running

Each sub project is its own gradle or grails application and can be run and tested independantly.
Please see the Grails [documentation](http://docs.grails.org/latest/) for how to use the CLI and how to develop using Grails.

Ensure the following database setup has been run
```bash
psql -U postgres
-- Create the development user
postgres=# CREATE USER maurodatamapper WITH SUPERUSER PASSWORD 'MauroDataMapper1234';
-- Create the database
postgres=# CREATE DATABASE maurodatamapper OWNER maurodatamapper;
```

### Standalone for backend testing

This will bring up all the current plugins/modules available to the MDM core.

```bash
cd mdm-testing-functional
grails run-app
```

### Development Mode

Any sub-project which provides domains must extend `uk.ac.ox.softeng.maurodatamapper.core.gorm.mapping.PluginSchemaHibernateMappingContext`
this class will provide the name of the schema to be used for those domains.

Use the Grails CLI to start the sub-project

```shell script
grails> run-app

# debug mode
grails> run-app --debug-jvm
```

## Migrating from Metadata Catalogue

Please see [MC to MDM Migration](https://github.com/MauroDataMapper/mc-to-mdm-migration#mc-to-mdm-migration) repository.

## Developing

### Working with the code

Please note the following:

**Use git flow for all repositories**

## Testing

All testing should be done using the Grails CLI.
Navigate into the desired sub-project and enter the CLI and use one of the below commands.

```shell script
# To run the unit tests only
grails> test-app -unit

# To run the integration tests (all tests in src/integration-test
grails> test-app -integration

# To run just the integration tests
grails> -Dgradle.integrationTest=true test-app -integration

# To run just the functional tests
grails> -Dgradle.functionalTest=true test-app -integration
# or
grails> test-app *FunctionalSpec -integration

# Add --debug-jvm to start a debugger hook
```

You can also run all the tests in the same format that Jenkins runs them by using the shell script as below. This will run all the tests in order and
generate a complete test report.

```shell
# Run the tests
$ ./run-all-tests.sh

# Open the complete test report
$ open build/reports/tests/index.html
```

All pushes and Pull Requests to the MauroDataMapper repo will produce a build inside our Jenkins system which will run all of the above tests.

Please note the Grails default setup is to place both integration tests and functional tests into the same directory and both use the same annotation
`grails.testing.mixin.integration.Integration` hence the reason we use system properties to allow running the tests separately.

## IDE Choice

Both Intellij and Eclipse plugins are installed however we recommend using Intellij.
We also provide all instructions using the gradle wrapper as that avoids worrying about which version of gradle you have installed.
However if you make use of SDKMan you can switch between versions quickly and easily using `sdk u gradle <version>`,
this will set the current terminal to that version.

### Using Intellij

Open the folder with Intellij and it will auto import the gradle project.

To make life easier with the Static Code Analysis we highly recommend importing the `OxfordBRC_Intellij_CodeStyle.xml` file which is in the
`gradle` folder in this repository.
This can be done by:

1. Intellij Preferences
1. Code Style
1. Click the 'gear' next to the Scheme
1. Import
1. Choose the XML file

This will provide a code style scheme for OxfordBRC work, and allow you to use the `Code` -> `Reformat Code` option to fully reformat
and optimise imports.
These settings will meet the checkstyle enforced by the Mauro Data Mapper code bases.

#### Checkstyle

The following will highlight any checkstyle issues as you type.

1. Install the `Checkstyle-IDEA` plugin, available from `Browse Repositories` in the `Preferences` -> `Plugins`
1. `Preferences` -> `Other Settings` -> `Checkstyle`
1. Add the `gradle/checkstyle.xml` file, and activate it

repository: GBishop-PHSA/mdm-core

repo_name: GBishop-PHSA/mdm-core


text:
# Introduction
When using an external JavaScript library, or new host API, you'll need to use a declaration file (.d.ts) to describe the shape of that library. This guide covers a few high-level concepts specific to writing definition files, then proceeds with a number of examples that show how to transcribe various concepts to their matching definition file descriptions.

# Guidelines and Specifics

## Workflow

The best way to write a .d.ts file is to start from the documentation of the library, not the code. Working from the documentation ensures the surface you present isn't muddied with implementation details, and is typically much easier to read than JS code. The examples below will be written as if you were reading documentation that presented example calling code.

## Namespacing

When defining interfaces (for example, "options" objects), you have a choice about whether to put these types inside a module or not. This is largely a judgement call -- if the consumer is likely to often declare variables or parameters of that type, and the type can be named without risk of colliding with other types, prefer placing it in the global namespace. If the type is not likely to be referenced directly, or can't be named with a reasonably unique name, do use a module to prevent it from colliding with other types.

## Callbacks

Many JavaScript libraries take a function as a parameter, then invoke that function later with a known set of arguments. When writing the function signatures for these types, *do not* mark those parameters as optional. The right way to think of this is _"What parameters will be provided?"_, not _"What parameters will be consumed?"_. While TypeScript 0.9.7 and above does not enforce that the optionality, bivariance on argument optionality might be enforced by an external linter.

## Extensibility and Declaration Merging

When writing definition files, it's important to remember TypeScript's rules for extending existing objects. You might have a choice of declaring a variable using an anonymous type or an interface type:

*Anonymously-typed var*

```
declare var MyPoint: { x: number; y: number; };
```

*Interfaced-typed var*

```
interface SomePoint { x: number; y: number; }
declare var MyPoint: SomePoint;
```

From a consumption side these declarations are identical, but the type {{SomePoint}} can be extended through interface merging:

```
interface SomePoint { z: number; }
MyPoint.z = 4; // OK
```

Whether or not you want your declarations to be extensible in this way is a bit of a judgement call. As always, try to represent the intent of the library here.

## Class Decomposition

Classes in TypeScript create two separate types: the instance type, which defines what members an instance of a class has, and the constructor function type, which defines what members the class constructor function has. The constructor function type is also known as the "static side" type because it includes static members of the class.

While you can reference the static side of a class using the {{typeof}} keyword, it is sometimes useful or necessary when writing definition files to use the _decomposed class_ pattern which explicitly separates the instance and static types of class.

As an example, the following two declarations are nearly equivalent from a consumption perspective:

*Standard*

```
class A {
    static st: string;
    inst: number;
    constructor(m: any) {}
}
```

*Decomposed*

```
interface A_Static {
    new(m: any): A_Instance;
    st: string;
}
interface A_Instance {
    inst: number;
}
declare var A: A_Static;
```

The trade-offs here are as follows:
* Standard classes can be inherited from using {{extends}}; decomposed classes cannot. This might change in later version of TypeScript if arbitrary {{extends}} expressions are allowed.
* It is possible to add members later (through declaration merging) to the static side of both standard and decomposed classes
* It is possible to add instance members to decomposed classes, but not standard classes
* You'll need to come up with sensible names for more types when writing a decomposed class

## Naming Conventions

In general, do not prefix interfaces with {{I}} (e.g. {{IColor}}). Because the concept of an interface in TypeScript is much more broad than in C# or Java, the {{IFoo}} naming convention is not broadly useful.

# Examples

Let's jump in to the examples section. For each example, sample _usage_ of the library is provided, followed by the definition code that accurately types the usage. When there are multiple good representations, more than one definition sample might be listed.

## Options Objects

*Usage*
```
animalFactory.create("dog");
animalFactory.create("giraffe", { name: "ronald" });
animalFactory.create("panda", { name: "bob", height: 400 });
// Invalid: name must be provided if options is given
animalFactory.create("cat", { height: 32 });
```

*Typing*
```
module animalFactory {
    interface AnimalOptions {
        name: string;
        height?: number;
        weight?: number;
    }
    function create(name: string, animalOptions?: AnimalOptions): Animal;
}
```

## Functions with Properties
*Usage*
```
zooKeeper.workSchedule = "morning";
zooKeeper(giraffeCage);
```

*Typing*
```
// Note: Function must precede module
function zooKeeper(cage: AnimalCage);
module zooKeeper {
    var workSchedule: string;
}
```

## New + callable methods
*Usage*
```
var w = widget(32, 16);
var y = new widget("sprocket");
// w and y are both widgets
w.sprock();
y.sprock();
```

*Typing*
```
interface Widget {
    sprock(): void;
}

interface WidgetFactory {
    new(name: string): Widget;
    (width: number, height: number): Widget;
}

declare var widget: WidgetFactory;
```

## Global / External-agnostic Libraries
*Usage*
```
// Either
import x = require('zoo');
x.open();
// or
zoo.open();
```

*Typing*
```
module zoo {
  function open(): void;
}

declare module "zoo" {
    export = zoo;
}
```

## Single Complex Object in External Modules
*Usage*
```
// Super-chainable library for eagles
import eagle = require('./eagle');
// Call directly
eagle('bald').fly();
// Invoke with new
var eddie = new eagle(1000);
// Set properties
eagle.favorite = 'golden';
```

*Typing*
```
// Note: can use any name here, but has to be the same throughout this file
declare function eagle(name: string): eagle;
declare module eagle {
    var favorite: string;
    function fly(): void;
}
interface eagle {
    new(awesomeness: number): eagle;
}

export = eagle;
```

## Callbacks
*Usage*
```
addLater(3, 4, (x) => console.log('x = ' + x));
```

*Typing*
```
// Note: 'void' return type is preferred here
function addLater(x: number, y: number, (sum: number) => void): void;
```

Please post a comment [here|https://github.com/Microsoft/TypeScript/issues] if there's a pattern you'd like to see documented# We'll add to this as we can.

repository: mhegazy/TypeScript-Handbook

path: /pages/Writing Definition Files.md

filename: Writing Definition Files.md

repo_name: mhegazy/TypeScript-Handbook


text:
# Fake adapter

Uses [json-schema-faker](https://www.npmjs.com/package/json-schema-faker#faking-values) which is configured
in the `/faker` root folder of `src`.

repository: kristianmandrup/artifactor-adapters

path: /test/adapters/fake/Fake adapter.md

filename: Fake adapter.md

repo_name: kristianmandrup/artifactor-adapters


text:
# PanDiff

[![Build Status](https://travis-ci.org/davidar/pandiff.svg?branch=master)](https://travis-ci.org/davidar/pandiff)
[![Gitpod ready-to-code](https://img.shields.io/badge/Gitpod-ready--to--code-blue?logo=gitpod)](https://gitpod.io/#https://github.com/davidar/pandiff)

## Features

- Prose diffs for [any document format supported by Pandoc](https://pandoc.org/MANUAL.html)
- Supported output formats:
  - [CriticMarkup](http://criticmarkup.com/)
  - HTML
  - PDF, via LaTeX
  - [Word docx](https://en.wikipedia.org/wiki/Office_Open_XML) with [Track Changes](https://support.office.com/en-us/article/track-changes-in-word-197ba630-0f5f-4a8e-9a77-3712475e806a)
- Respects document structure, so won't produce broken markup like `wdiff`

## Installation

First install [Pandoc](https://pandoc.org/installing.html) and [npm](https://www.npmjs.com/get-npm), then run:

```sh
npm install -g pandiff
```

## Usage

```sh
pandiff test/old.md test/new.md
```

````markdown
{~~Old~>New~~} Title
====================

{--![image](minus.png)--}

{++![image](plus.png)++}

1.  Lorem ipsum dolor {++sit ++}amet
2.  {++[consectetur adipiscing
elit](https://en.wikipedia.org/wiki/Lorem_ipsum)++}
3.   The world owes you nothing. It was here first. {~~One~>Only
one~~} thing is impossible for God: To find{++ any++} sense in any
copyright law on the planet. Truth is stranger than fiction, but it is
because Fiction is obliged to stick to possibilities; Truth isn’t.
````

### Options

```sh
pandiff --help
```

```
Usage: pandiff [OPTIONS] FILE1 FILE2
      --bibliography=FILE
      --csl=FILE
      --columns=NUMBER
      --extract-media=PATH
  -F, --filter=STRING
  -f, --from=FORMAT
  -h, --help
      --highlight-style=STRING
      --lua-filter=FILE
      --mathjax=BOOL
      --mathml=BOOL
  -o, --output=FILE
      --pdf-engine=STRING
      --reference-dic=FILE
      --reference-links
      --resource-path=PATH
  -s, --standalone
  -t, --to=FORMAT
  -v, --version
      --wrap=STRING
```

### Git integration

Configure git by running the following commands:

```sh
git config --global difftool.pandiff.cmd 'pandiff "$LOCAL" "$REMOTE"'
git config --global alias.pandiff 'difftool -t pandiff -y'
```

Now you can use `git pandiff` wherever you would usually use `git diff`.

### HTML output

```sh
pandiff old.md new.md -s -o diff.html
```

[![](test/diff.html.png)](https://rawgit.com/davidar/pandiff/master/test/diff.html)

### PDF output

```sh
pandiff old.md new.md -o diff.pdf
```

[![](test/diff.pdf.png)](https://rawgit.com/davidar/pandiff/master/test/diff.pdf)

### Word Track Changes

```sh
pandiff old.md new.md -o diff.docx
```

```sh
pandiff test/track_changes_move.docx
```

```markdown
Here is some text.

{++Here is the text to be moved.++}

Here is some more text.

{--Here is the text to be moved.--}
```

repository: davidar/pandiff

repo_name: davidar/pandiff


text:
[//]: # (This file was autogenerated using `zio-sbt-website` plugin via `sbt generateReadme` command.)
[//]: # (So please do not edit it manually. Instead, change "docs/index.md" file or sbt setting keys)
[//]: # (e.g. "readmeDocumentation" and "readmeSupport".)

# ZIO Http

ZIO HTTP is a scala library for building http apps. It is powered by ZIO and [Netty](https://netty.io/) and aims at being the defacto solution for writing, highly scalable and performant web applications using idiomatic Scala.

[![Development](https://img.shields.io/badge/Project%20Stage-Development-green.svg)](https://github.com/zio/zio/wiki/Project-Stages) ![CI Badge](https://github.com/zio/zio-http/workflows/Continuous%20Integration/badge.svg) [![Sonatype Releases](https://img.shields.io/nexus/r/https/oss.sonatype.org/dev.zio/zio-http_2.13.svg?label=Sonatype%20Release)](https://oss.sonatype.org/content/repositories/releases/dev/zio/zio-http_2.13/) [![Sonatype Snapshots](https://img.shields.io/nexus/s/https/oss.sonatype.org/dev.zio/zio-http_2.13.svg?label=Sonatype%20Snapshot)](https://oss.sonatype.org/content/repositories/snapshots/dev/zio/zio-http_2.13/) [![javadoc](https://javadoc.io/badge2/dev.zio/zio-http-docs_2.13/javadoc.svg)](https://javadoc.io/doc/dev.zio/zio-http-docs_2.13) [![ZIO Http](https://img.shields.io/github/stars/zio/zio-http?style=social)](https://github.com/zio/zio-http)

## Installation

Setup via `build.sbt`:

```scala
libraryDependencies += "dev.zio" %% "zio-http" % "3.0.0-RC2"
```

**NOTES ON VERSIONING:**

- Older library versions `1.x` or `2.x` with organization `io.d11` of ZIO Http are derived from Dream11, the organization that donated ZIO Http to the ZIO organization in 2022.
- Newer library versions, starting in 2023 and resulting from the ZIO organization (`dev.zio`) started with `0.0.x`, reaching `1.0.0` release candidates in April of 2023

## Getting Started

A simple Http server can be built using a few lines of code.

```scala
import zio._
import zio.http._

object HelloWorld extends ZIOAppDefault {

  val app: HttpApp[Any] =
    Routes(
      Method.GET / "text" -> handler(Response.text("Hello World!"))
    ).toHttpApp

  override val run =
    Server.serve(app).provide(Server.default)
}
```

## Steps to run an example

1. Edit the [RunSettings](https://github.com/zio/zio-http/blob/main/project/BuildHelper.scala#L107) - modify `className` to the example you'd like to run.
2. From sbt shell, run `~example/reStart`. You should see `Server started on port: 8080`.
3. Send curl request for defined `http Routes`, for eg : `curl -i "http://localhost:8080/text"` for `example.HelloWorld`.

## Watch Mode

You can use the [sbt-revolver] plugin to start the server and run it in watch mode using `~ reStart` command on the SBT console.

[sbt-revolver]: https://github.com/spray/sbt-revolver

## Documentation

Learn more on the [ZIO Http homepage](https://github.com/zio/zio-http)!

## Contributing

For the general guidelines, see ZIO [contributor's guide](https://zio.dev/about/contributing).

## Code of Conduct

See the [Code of Conduct](https://zio.dev/about/code-of-conduct)

## Support

Come chat with us on [![Badge-Discord]][Link-Discord].

[Badge-Discord]: https://img.shields.io/discord/629491597070827530?logo=discord "chat on discord"
[Link-Discord]: https://discord.gg/2ccFBr4 "Discord"

## License

[License](LICENSE)

repository: zio/zio-http

gha_language: Scala

repo_name: zio/zio-http


text:
GithubPullrequestCommenter
==========================

tool to append a given message to the given pull request in the given repo

Usage: pullrequest-commenter-cli options

```
   OPTION                            TYPE       POSITION   DESCRIPTION
   -Owner (-o)                       string*    0          Owner of repository to which we are going to send the message
   -Repository (-r)                  string*    1          Repository to which we are going to send the message
   -PullRequestId (-i)               integer*   2          The pull request / issue to which we are going to add this comment
   -PersonalGithubAccessToken (-t)   string*    3          The github personal access token, retrieved @https://help.github.com/articles/creating-an-access-token-for-command-line-use
   -Message (-m)                     string*    4          The commit message to append
```

# Source

https://github.com/crunchie84/GithubPullrequestCommenter


text:
---
title: Troubleshooting
---

# Troubleshooting

Your machine is not starting, behaving weird or crashing? We are sorry
to hear that. This chapter tries to help you to help yourself. Please
try to find the root of your problem. Maybe the solution will be obvious
then. If not we will help you in the forum.

Please remember that this is a two step process: First, try to diagnose
the problem and collect as much information as possible. Second, report
the issue if you cannot find a solution yourself. If you skip the first
step we will likely send you to this page.

## Step 1: Diagnosing Your Issue

Do you already know
[how to turn on debugging and increase log verbosity](general_debugging.md)?

What kind of issue are you having?

* [Memory leaks](debugging_memory_leaks.md)
* [YAML parse errors](debugging_yaml_parse_errors.md)
* [Seg faults](debugging_segfaults.md)
* .[MPF installation issues](debugging_mpf_install.md)

If you coils are not firing, switches are not working or hardware is
behaving weirdly in general read our
[hardware troubleshooting guide](../hardware/troubleshooting_hardware.md).

## Step 2: Prepare a Report and Ask in the Forum

Please include the following information if available and relevant:

### Output of MPF diagnosis

If your game won't run, let's make sure MPF is ok. This will also tell
use which MPF and MPF-MC version you are using. Run `mpf diagnosis` from
within your machine folder to see if your installation is fine:

``` console
$ mpf diagnosis

MPF version: MPF v0.50.0-dev.11
MPF install location: /data/home/jan/cloud/flipper/src/mpf/mpf
Machine folder detected: /data/home/jan/cloud/flipper/src/good_vs_evil
MPF-MC version: MPF-MC v0.50.0-dev.5 (config_version=5, BCP v1.1, Requires MPF v0.50.0-dev.10)

Serial ports found:
/dev/ttyUSB3
    desc: Quad RS232-HS
    hwid: USB VID:PID=0403:6011 LOCATION=1-12
/dev/ttyUSB2
    desc: Quad RS232-HS
    hwid: USB VID:PID=0403:6011 LOCATION=1-12
/dev/ttyUSB1
    desc: Quad RS232-HS
    hwid: USB VID:PID=0403:6011 LOCATION=1-12
/dev/ttyUSB0
    desc: Quad RS232-HS
    hwid: USB VID:PID=0403:6011 LOCATION=1-12
```

## Relevant Configuration

Please provide the relevant configuration snippets. Leave out anything
which is not related. For instance if you got problems with lights on
your P-Roc or FAST platform provide the configuration for the relevant
lights, the `p_roc` or `fast` section and any light_players or shows
which are used when the problem occurs.

## Attach a Log with debug and verbose logging

Please attach the log with verbose logging from MPF or MPF-MC (depending
where your problem occurred). Make sure you enabled `debug` on the
relevant devices and/or platforms. See
[how to turn on debugging and increase log verbosity](general_debugging.md) for details.

A link to your machine config also help. Ideally this would be some git
repository which can be checked out and browsed online.

## Prepare the Error Message

Your error message likely is inside your log. However, please include it
inside your message as well. See [Reading MPF Errors](reading_errors.md) for how to read the error.

Please check the relevant device or platform documentation for any
mentions of that error. Often we already documented how to solve it.

## Tell Us How to Reproduce Your Problem

It might be hard for us to help you if we cannot reproduce your issue.
Is there a way you can provide a minimal config which shows your
problem? Try to remove everything unrelated to your problem and bring it
to its bare minimum. Sometimes you will find the root of the issue while
doing this. You would be surprised how often issues are caused by
seemingly unrelated devices or configs.

Ideally you can provide a
[single file test](../tools/test.md)
which fails or shows your issue in its log. This allows us to verify the
issue quickly and provide a quick fix. But don't worry if this not
possible. Just a minimal machine config is also fine. In that case
please tell us how to run your machine to experience the issue.

## Ask In the Forum

With all this information, now you can ask in our [a support forum](../community/index.md). Please keep
in mind that MPF is an open source project and we are doing this for fun
in our spare time. Be kind and patient. If you provide more relevant
information it is likely that somebody can help you. More is not always
better if it is not relevant to your problem. But missing information
will just delay the overall process.

1.  If you have a problem with a device (e.g. a ball_lock) or a platform
    (e.g. P-ROC or FAST) add `debug: True` to the relevant config
    section to enable extra debug output.
2.  Add a log of your game. Therefore, run your game with
    `mpf both -v -V` and grab the latest MPF and MC log from the log
    folder in your machine.
3.  Describe how to reproduce your problem.
4.  Provide relevant config snippets or, if possible, a link to
    download/checkout your machine config so we can reproduce the issue.

## Consider Improving the Documentation

Did you solve your issue but found that some relevant information in the
documentation is missing or should be linked/located elsewhere?

## More How-tos

* [General Debugging](general_debugging.md)

repository: missionpinball/mpf-docs

gha_language: Python

repo_name: missionpinball/mpf-docs


text:
# remark-html

[![Build][build-badge]][build]
[![Coverage][coverage-badge]][coverage]
[![Downloads][downloads-badge]][downloads]
[![Size][size-badge]][size]
[![Sponsors][sponsors-badge]][collective]
[![Backers][backers-badge]][collective]
[![Chat][chat-badge]][chat]

[**remark**][remark] plugin to serialize Markdown as HTML.

> ⚠ This package essentially packs [`remark-rehype`][remark-rehype] and
> [`rehype-stringify`][rehype-stringify], and although it does support some
> customisation, it isn’t very pluggable.
> It’s probably smarter to use `remark-rehype` directly and benefit from the
> [**rehype**][rehype] ecosystem.

## Install

This package is [ESM only](https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c):
Node 12+ is needed to use it and it must be `import`ed instead of `require`d.

[npm][]:

```sh
npm install remark-html
```

## Use

Say we have the following file, `example.md`:

```markdown
# Hello & World

> A block quote.

* Some _emphasis_, **importance**, and `code`.
```

And our module, `example.js`, looks as follows:

```js
import fs from 'node:fs'
import {unified} from 'unified'
import remarkParse from 'remark-parse'
import remarkHtml from 'remark-html'

const buf = fs.readFileSync('example.md')

unified()
  .use(remarkParse)
  .use(remarkHtml)
  .process(buf)
  .then((file) => {
    console.log(String(file))
  })
```

Now, running `node example` yields:

```html
<h1>Hello & World</h1>
<blockquote>
<p>A block quote.</p>
</blockquote>
<ul>
<li>Some <em>emphasis</em>, <strong>importance</strong>, and <code>code</code>.</li>
</ul>
```

## API

This package exports no identifiers.
The default export is `remarkHtml`.

### `unified().use(remarkHtml[, options])`

Serialize Markdown as HTML.

##### `options`

All options except for `sanitize` and `handlers` are passed to
[`hast-util-to-html`][to-html].

The underlying tools allow much more customisation.
It is recommended to replace this project with [`remark-rehype`][remark-rehype]
and [`rehype-stringify`][rehype-stringify] ;

###### `options.handlers`

Object mapping [mdast][] [nodes][mdast-node] to functions handling them.
This option is passed to [`mdast-util-to-hast`][to-hast-handlers].

###### `options.sanitize`

How to sanitize the output (`Object` or `boolean`, default: `true`):

*   `false`
    — HTML is not sanitized, dangerous HTML persists
*   `true`
    — HTML is sanitized according to [GitHub’s sanitation rules][github],
    dangerous HTML is dropped
*   `Object`
    — the object is treated as a `schema` for how to sanitize with
    [`hast-util-sanitize`][sanitize], dangerous HTML is dropped

> Note that raw HTML in Markdown cannot be sanitized, so it’s removed.
> A schema can still be used to allow certain values from other plugins
> though.
> To support HTML in Markdown, use [`rehype-raw`][raw].

For example, to add strict sanitation but allowing `className`s, use something
like:

```js
// ...
var merge = require('deepmerge')
var github = require('hast-util-sanitize/lib/github')

var schema = merge(github, {attributes: {'*': ['className']}})

remark()
  .use(html, {sanitize: schema})
  .processSync(/* … */)
```

## Security

Use of `remark-html` is *unsafe* by default and opens you up to a
[cross-site scripting (XSS)][xss] attack.
Pass `sanitize: true` to prevent attacks.
Settings `sanitize` to anything else may be unsafe.

## Contribute

See [`contributing.md`][contributing] in [`remarkjs/.github`][health] for ways
to get started.
See [`support.md`][support] for ways to get help.

This project has a [code of conduct][coc].
By interacting with this repository, organization, or community you agree to
abide by its terms.

## License

[MIT][license] © [Titus Wormer][author]

<!-- Definitions -->

[build-badge]: https://github.com/remarkjs/remark-html/workflows/main/badge.svg

[build]: https://github.com/remarkjs/remark-html/actions

[coverage-badge]: https://img.shields.io/codecov/c/github/remarkjs/remark-html.svg

[coverage]: https://codecov.io/github/remarkjs/remark-html

[downloads-badge]: https://img.shields.io/npm/dm/remark-html.svg

[downloads]: https://www.npmjs.com/package/remark-html

[size-badge]: https://img.shields.io/bundlephobia/minzip/remark-html.svg

[size]: https://bundlephobia.com/result?p=remark-html

[sponsors-badge]: https://opencollective.com/unified/sponsors/badge.svg

[backers-badge]: https://opencollective.com/unified/backers/badge.svg

[collective]: https://opencollective.com/unified

[chat-badge]: https://img.shields.io/badge/chat-discussions-success.svg

[chat]: https://github.com/remarkjs/remark/discussions

[npm]: https://docs.npmjs.com/cli/install

[health]: https://github.com/remarkjs/.github

[contributing]: https://github.com/remarkjs/.github/blob/HEAD/contributing.md

[support]: https://github.com/remarkjs/.github/blob/HEAD/support.md

[coc]: https://github.com/remarkjs/.github/blob/HEAD/code-of-conduct.md

[license]: license

[author]: https://wooorm.com

[remark]: https://github.com/remarkjs/remark

[remark-rehype]: https://github.com/remarkjs/remark-rehype

[rehype]: https://github.com/rehypejs/rehype

[rehype-stringify]: https://github.com/rehypejs/rehype/tree/HEAD/packages/rehype-stringify

[raw]: https://github.com/rehypejs/rehype-raw

[mdast]: https://github.com/syntax-tree/mdast

[mdast-node]: https://github.com/syntax-tree/mdast#nodes

[to-html]: https://github.com/syntax-tree/hast-util-to-html

[to-hast-handlers]: https://github.com/syntax-tree/mdast-util-to-hast#optionshandlers

[sanitize]: https://github.com/syntax-tree/hast-util-sanitize

[github]: https://github.com/syntax-tree/hast-util-sanitize#schema

[xss]: https://en.wikipedia.org/wiki/Cross-site_scripting

repository: anassallem/nextjs-blog

repo_name: anassallem/nextjs-blog


text:
# SNUH

The PyTorch (1.2.0) implementation of "Integrating Semantics and Neighborhood Information with Graph-Driven Generative Models for Document Retrieval" (ACL 2021).

The MindSpore implementation is available in [this repo](https://github.com/J-zin/SNUH-mindspore).

## Datasets

We follow the setting of VDSH [(Chaidaroon and Fang, 2017)](https://arxiv.org/pdf/1708.03436.pdf).  Please download the data from [here](https://github.com/unsuthee/VariationalDeepSemanticHashing/tree/master/dataset) and move them into the `./data/` directory.

## Quick start

Unsupervised document hashing on 20Newsgroups using 64 bits

```bash
python main.py ng64 data/ng20.tfidf.mat --train --cuda
```

To reproduce the results reported in the paper, please refer to the `run.sh` for detailed running commands.

## Acknowledgement

The coding logic follows the project organization in [AMMI](https://github.com/karlstratos/ammi).

## License

This code is offered under the [MIT License](https://opensource.org/licenses/MIT).

## References
[1] [Integrating Semantics and Neighborhood Information with Graph-Driven Generative Models for Document Retrieval](https://arxiv.org/pdf/2105.13066.pdf)
```
@article{zijing2021snuh,
  author    = {Zijing Ou and
               Qinliang Su and
               Jianxing Yu and
               Bang Liu and
               Jingwen Wang and
               Ruihui Zhao and
               Changyou Chen and
               Yefeng Zheng},
  title     = {Integrating Semantics and Neighborhood Information with Graph-Driven
               Generative Models for Document Retrieval},
  journal   = {arXiv preprint arXiv:2105.13066},
  year      = {2021},
}
```

repository: J-zin/SNUH

repo_name: J-zin/SNUH


text:
# Learning with examples
The following examples are a nice and easy way to progressively go through using Pixpipe, from the basics to advanced. It is important to understand how to use Pixpipe before trying to develop your own filters in order to respect the coherence that makes it easy to use.
You can run and explore the source of all the examples, they are simple HTML pages and links are all provided.

Before starting, remember these two things:
- Filters take one or more input using the method `addInput()`, must be ran using `update()` and produce one or more output that can be accessed with `getOutput()`
- When a filter takes multiple inputs, the method `addInput()` takes an additional argument to identify it. Read the [code documentation](pixpipe.github.io/pixpipejs/doc/) to find out what are the *categories* of the expected inputs.
- The method `getOutput()` has the same feature. If multiple are expected, the method will take an argument (*string*) that is the *category* of the output. Though you can alway use the method `.forEachOutput(...)` - [doc](http://www.pixpipe.io/pixpipejs/doc/#Filter.forEachOutput)
- When it comes to containers' metadata (particular setting, overwriting a default algorithm value, etc.), the filter method `.setMetadata(...)` must be called.
- A `Filter` should **NEVER** modify the input data and it's the duty of the developer to respect that.

```Javascript
// the object myImage comes from a file that you previously opened

var myFilter = new pixpipe.AmazingFilter();

// Some filter have specific setting, if so, they have default values but you can still change them:
myFilter.setMetadata( "someSetting", 42 );
myFilter.setMetadata( "someOtherSetting", "gaussian" );

// If the filter is supposed to take a single input, this is enough:
myFilter.addInput( myImage );
// and this is exactly the same as doing
myFilter.addInput( myImage, 0 );

// But is the filter expect multiple inputs, we have to specify the "category" of each:
myFilter.addInput( myImage, "principalImage" );
myFilter.addInput( myImage2, "secondaryImage" );

// run the filter
myFilter.update();

// Get the output from the filter. Can be null if not successful:
var myOutputImage = myFilter.getOutput();
// which is the same as
var myOutputImage = myFilter.getOutput( 0 );

// but a filter can produce multiple outputs. In this case, they are identified with a "category":
var myOutputImageBlue = myFilter.getOutput( "blueBand" );
var myOutputImageRed = myFilter.getOutput( "redBand" );

// in any case, before going further, ew should test this output:
if( myOutputImage ){
  //...
  // do something here
}

// If a filter produces multiple outputs, you can also access them like that:
myFilter.forEachOutput( function( category, out ){
  // where "category" is a string
  // and "out" is the output object, e.g. an instance of Image2D
});
```

Processing images/volumes usually take a bit of time but there is not always a graphic feedback. Open your javascript console so that you can see the filter feedback in the log.
The examples from the following pages are in the [example folder](https://github.com/Pixpipe/pixpipejs/tree/master/examples) of Pixpipe's repo.

repository: Pixpipe/cookbook

repo_name: Pixpipe/cookbook


text:
## Annotated Best Practices

Edit the markdown document: `web/2016/day2/docs/best_practices_keep_or_toss.md`

Add your choices below. Write them in the following format.

---

by `ialbert`

### KEEP Rule 1.1 Keep it simple

Simplicity is the most powerful virtue that any process
can have. There is only one problem: it is kind of
difficult to keep it simple

### KEEP Rule 3.1: Small steps with frequent feedback

There is great value in keep the entire pipeline working at most times.
Save often, commit often. Rerun often.

### KEEP Rule 3.3: Version control EVERYTHING

While git was designed for software you should keep everything (other
than large datasets) in it. You get free backup and replication with it!

### TOSS Rule 5.4 Use a symbolic debugger.

There is nothing wrong with print statements.
Symbolic debuggers promote writing complex programs.
If you can't debug a program with simple print
statements your program may be already too complicated.

### TOSS Rule 8.1 Use pre-merge code reviews

This is a concept borrowed from software engineering where
it is assumed that all people on a team work on a the exact same
and relatively simple problem. This rarely happens in sciences.
This rule is one of these "feel good" rules that are just unrealistic in
scientific practice.

### TOSS Rule 8.2 Use pair programming

Pair programming is again a concept borrowed from
software engineering. But it disregards the fact that most
software engineers need to solve
far simpler and far better defined problems than
scientists do. It is sort of a pipe dream that we can do this.

---

repository: biostars/bootcamp-central

gha_language: HTML

repo_name: biostars/bootcamp-central


text:
PEP: 3113 Title: Removal of Tuple Parameter Unpacking Version:
$Revision$ Last-Modified: $Date$ Author: Brett Cannon<EMAIL_ADDRESS>Status: Final Type: Standards Track Content-Type: text/x-rst Created:
02-Mar-2007 Python-Version: 3.0 Post-History:

Abstract
========

Tuple parameter unpacking is the use of a tuple as a parameter in a
function signature so as to have a sequence argument automatically
unpacked. An example is::

def fxn(a, (b, c), d): pass

The use of `(b, c)` in the signature requires that the second argument
to the function be a sequence of length two (e.g., `[42, -13]`). When
such a sequence is passed it is unpacked and has its values assigned to
the parameters, just as if the statement `b, c = [42, -13]` had been
executed in the parameter.

Unfortunately this feature of Python's rich function signature
abilities, while handy in some situations, causes more issues than they
are worth. Thus this PEP proposes their removal from the language in
Python 3.0.

Why They Should Go
==================

Introspection Issues
--------------------

Python has very powerful introspection capabilities. These extend to
function signatures. There are no hidden details as to what a function's
call signature is. In general it is fairly easy to figure out various
details about a function's signature by viewing the function object and
various attributes on it (including the function's `func_code`
attribute).

But there is great difficulty when it comes to tuple parameters. The
existence of a tuple parameter is denoted by its name being made of a
`.` and a number in the `co_varnames` attribute of the function's code
object. This allows the tuple argument to be bound to a name that only
the bytecode is aware of and cannot be typed in Python source. But this
does not specify the format of the tuple: its length, whether there are
nested tuples, etc.

In order to get all of the details about the tuple from the function one
must analyse the bytecode of the function. This is because the first
bytecode in the function literally translates into the tuple argument
being unpacked. Assuming the tuple parameter is named `.1` and is
expected to unpack to variables `spam` and `monty` (meaning it is the
tuple `(spam, monty)`), the first bytecode in the function will be for
the statement `spam, monty = .1`. This means that to know all of the
details of the tuple parameter one must look at the initial bytecode of
the function to detect tuple unpacking for parameters formatted as
`\.\d+` and deduce any and all information about the expected argument.
Bytecode analysis is how the `inspect.getargspec` function is able to
provide information on tuple parameters. This is not easy to do and is
burdensome on introspection tools as they must know how Python bytecode
works (an otherwise unneeded burden as all other types of parameters do
not require knowledge of Python bytecode).

The difficulty of analysing bytecode not withstanding, there is another
issue with the dependency on using Python bytecode. IronPython
\[\#ironpython\]\_ does not use Python's bytecode. Because it is based
on the .NET framework it instead stores MSIL \[\#MSIL\]\_ in
`func_code.co_code` attribute of the function. This fact prevents the
`inspect.getargspec` function from working when run under IronPython. It
is unknown whether other Python implementations are affected but is
reasonable to assume if the implementation is not just a
re-implementation of the Python virtual machine.

No Loss of Abilities If Removed
-------------------------------

As mentioned in `Introspection Issues`*, to handle tuple parameters the
function's bytecode starts with the bytecode required to unpack the
argument into the proper parameter names. This means that there is no
special support required to implement tuple parameters and thus there is
no loss of abilities if they were to be removed, only a possible
convenience (which is addressed in
`Why They Should (Supposedly) Stay`*).

The example function at the beginning of this PEP could easily be
rewritten as::

def fxn(a, b\_c, d): b, c = b\_c pass

and in no way lose functionality.

Exception To The Rule
---------------------

When looking at the various types of parameters that a Python function
can have, one will notice that tuple parameters tend to be an exception
rather than the rule.

Consider PEP 3102 (keyword-only arguments) and PEP 3107 (function
annotations) \[\#pep-3102\]\_ \[\#pep-3107\]\_. Both PEPs have been
accepted and introduce new functionality within a function's signature.
And yet for both PEPs the new feature cannot be applied to tuple
parameters as a whole. PEP 3102 has no support for tuple parameters at
all (which makes sense as there is no way to reference a tuple parameter
by name). PEP 3107 allows annotations for each item within the tuple
(e.g., `(x:int, y:int)`), but not the whole tuple (e.g., `(x, y):int`).

The existence of tuple parameters also places sequence objects
separately from mapping objects in a function signature. There is no way
to pass in a mapping object (e.g., a dict) as a parameter and have it
unpack in the same fashion as a sequence does into a tuple parameter.

Uninformative Error Messages
----------------------------

Consider the following function::

def fxn((a, b), (c, d)): pass

If called as `fxn(1, (2, 3))` one is given the error message
`TypeError: unpack non-sequence`. This error message in no way tells you
which tuple was not unpacked properly. There is also no indication that
this was a result that occurred because of the arguments. Other error
messages regarding arguments to functions explicitly state its relation
to the signature:
`TypeError: fxn() takes exactly 2 arguments (0 given)`, etc.

Little Usage
------------

While an informal poll of the handful of Python programmers I know
personally and from the PyCon 2007 sprint indicates a huge majority of
people do not know of this feature and the rest just do not use it, some
hard numbers is needed to back up the claim that the feature is not
heavily used.

Iterating over every line in Python's code repository in the `Lib/`
directory using the regular expression `^\s*def\s*\w+\s*\(` to detect
function and method definitions there were 22,252 matches in the trunk.

Tacking on `.*,\s*\(` to find `def` statements that contained a tuple
parameter, only 41 matches were found. This means that for `def`
statements, only 0.18% of them seem to use a tuple parameter.

Why They Should (Supposedly) Stay
=================================

Practical Use
-------------

In certain instances tuple parameters can be useful. A common example is
code that expects a two-item tuple that represents a Cartesian point.
While true it is nice to be able to have the unpacking of the x and y
coordinates for you, the argument is that this small amount of practical
usefulness is heavily outweighed by other issues pertaining to tuple
parameters. And as shown in `No Loss Of Abilities If Removed`\_, their
use is purely practical and in no way provide a unique ability that
cannot be handled in other ways very easily.

Self-Documentation For Parameters
---------------------------------

It has been argued that tuple parameters provide a way of
self-documentation for parameters that are expected to be of a certain
sequence format. Using our Cartesian point example from
`Practical Use`\_, seeing `(x, y)` as a parameter in a function makes it
obvious that a tuple of length two is expected as an argument for that
parameter.

But Python provides several other ways to document what parameters are
for. Documentation strings are meant to provide enough information
needed to explain what arguments are expected. Tuple parameters might
tell you the expected length of a sequence argument, it does not tell
you what that data will be used for. One must also read the docstring to
know what other arguments are expected if not all parameters are tuple
parameters.

Function annotations (which do not work with tuple parameters) can also
supply documentation. Because annotations can be of any form, what was
once a tuple parameter can be a single argument parameter with an
annotation of `tuple`, `tuple(2)`, `Cartesian point`, `(x, y)`, etc.
Annotations provide great flexibility for documenting what an argument
is expected to be for a parameter, including being a sequence of a
certain length.

Transition Plan
===============

To transition Python 2.x code to 3.x where tuple parameters are removed,
two steps are suggested. First, the proper warning is to be emitted when
Python's compiler comes across a tuple parameter in Python 2.6. This
will be treated like any other syntactic change that is to occur in
Python 3.0 compared to Python 2.6.

Second, the 2to3 refactoring tool \[\#2to3\]\_ will gain a fixer
\[\#fixer\]\_ for translating tuple parameters to being a single
parameter that is unpacked as the first statement in the function. The
name of the new parameter will be changed. The new parameter will then
be unpacked into the names originally used in the tuple parameter. This
means that the following function::

def fxn((a, (b, c))): pass

will be translated into::

def fxn(a\_b\_c): (a, (b, c)) = a\_b\_c pass

As tuple parameters are used by lambdas because of the single expression
limitation, they must also be supported. This is done by having the
expected sequence argument bound to a single parameter and then indexing
on that parameter::

lambda (x, y): x + y

will be translated into::

lambda x\_y: x\_y\[0\] + x\_y\[1\]

References
==========

.. \[\#2to3\] 2to3 refactoring tool
(http://svn.python.org/view/sandbox/trunk/2to3/)

.. \[\#fixer\] 2to3 fixer
(http://svn.python.org/view/sandbox/trunk/2to3/fixes/fix\_tuple\_params.py)

.. \[\#ironpython\] IronPython
(http://www.codeplex.com/Wiki/View.aspx?ProjectName=IronPython)

.. \[\#MSIL\] Microsoft Intermediate Language
(http://msdn.microsoft.com/library/en-us/cpguide/html/cpconmicrosoftintermediatelanguagemsil.asp?frame=true)

.. \[\#pep-3102\] PEP 3102 (Keyword-Only Arguments)
(http://www.python.org/dev/peps/pep-3102/)

.. \[\#pep-3107\] PEP 3107 (Function Annotations)
(http://www.python.org/dev/peps/pep-3107/)

Copyright
=========

This document has been placed in the public domain.

 .. Local Variables: mode: indented-text indent-tabs-mode: nil
sentence-end-double-space: t fill-column: 70 coding: utf-8 End:

repository: erdal-pb/opep

repo_name: erdal-pb/opep


text:
#### Purpose ####:

> G0rKing was created as the Capstone Project delivery for the completion of the COHORT-3 course and certification.
> COHORT-3 was offered through the joint initiative of C3i Center (IIT, Kanpur) and Talentsprint in the year 2021.
> The course title is "Advanced Certification Program in Cyber Security and Cyber Defense"

					#### Objective ####:

> The objective of G0rKing is to automate the Google Dorking process and offers a way to save the end results in a text file for easy reference and reporting purposes.
> It can also automate the process of checking one URL against multiple dorks and can hence provide a quick health check.

					#### Inital Project Content ####:

1. G0rKing - Google Dorking Tool written in Python3
2. Google and PyFiglet - Installable Requirements
3. Google Dorking Usage and Easy Reference - Text File

					#### Initial Project Team Members for COHORT-3 ####

 Vishal Soni

 Dhanaraj K S

 Neelakshi Sahni

 Gagan Nagpal

 Jisso Jose

 Prateek Bhattacharya

We were known as the team:  # ! Blue Virtual Nerds ! #

--------------------------------------

 How to run G0rKing

Follow the commands now ...
```
$ git clone https://github.com/PrateekOWASP/G0rKing
$ cd G0rKing
$ pip3 install -r requirements.txt
$ python3 G0rKing
```
.....and now follow the on-screen guide

				*************** Thank You *******************


text:
# socket.engine

## Installation

Python:

```
pip install socket.engine
```

This library requires Python3. It was tested extensively on Python 3.7.5 with Ubuntu 19.04.

## Documentation and Examples

[Transport Connections](https://github.com/0xJeremy/socket.engine/blob/master/python/docs/Transport_Documentation.md)

[Router Connections](https://github.com/0xJeremy/socket.engine/blob/master/python/docs/Router_Documentation.md)

[Host / Client Connections](https://github.com/0xJeremy/socket.engine/blob/master/python/docs/HostClient_Documentation.md)

## Tests

To run tests, be in the `socket.engine/python` directory, and use `python3 -m unittest test.[test name]`

(Example `python3 -m unittest test.transport_test`)


text:
---
title: Language assistant in Pig Editor with Navigator
author: admin
type: post
date: 2013-12-05T16:46:07+00:00
url: /hadoop-tutorial-language-assistant-in-pig-editor-with/
tumblr_gethue_permalink:
  - http://gethue.tumblr.com/post/69083414731/hadoop-tutorial-language-assistant-in-pig-editor-with
tumblr_gethue_id:
  -<PHONE_NUMBER>1
sf_thumbnail_type:
  - none
sf_thumbnail_link_type:
  - link_to_post
sf_detail_type:
  - none
sf_page_title:
  - 1
sf_page_title_style:
  - standard
sf_no_breadcrumbs:
  - 1
sf_page_title_bg:
  - none
sf_page_title_text_style:
  - light
sf_background_image_size:
  - cover
sf_social_sharing:
  - 1
sf_sidebar_config:
  - left-sidebar
sf_left_sidebar:
  - Sidebar-2
sf_right_sidebar:
  - Sidebar-1
sf_caption_position:
  - caption-right
slide_template:
  - default
categories:
  - Querying

---

  In Hue 3.5, a new assistant was added to the Pig Editor: Navigator.

Similarly to the [Hive][1] and [Impala][2] Editors, functions and Pig statements are made directly available from within the editor:

Navigator is:

  * Sorted by category
  * Searchable
  * Auto-completable (as well as HDFS paths and Metastore tables)

So now, get started with [Apache Pig][3]!

 [1]: http://gethue.tumblr.com/post/64916325309/hadoop-tutorial-hive-query-editor-with-hiveserver2-and
 [2]: http://gethue.tumblr.com/post/62452792255/fast-sql-with-the-impala-query-editor
 [3]: http://pig.apache.org/