text:
8 <https://www.python.org/dev/peps/pep-0008/>`_ guidelines
* Improved documentation and examples

0.1.0
-----

This is an early preview release of the toolkit that matches the functionality described in the preprint describing the SMIRNOFF v0.1 force field format: `[DOI] <https://doi.org/10.1101/286542>`_.

New features
""""""""""""

This release features additional documentation, code comments, and support for automated testing.

Bugfixes
""""""""

Treatment of improper torsions
''''''''''''''''''''''''''''''

A significant (though currently unused) problem in handling of improper torsions was corrected.
Previously, non-planar impropers did not behave correctly, as six-fold impropers have two potential chiralities.
To remedy this, SMIRNOFF impropers are now implemented as three-fold impropers with consistent chirality.
However, current force fields in the SMIRNOFF format had no non-planar impropers, so this change is mainly aimed at future work.

:::

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
---
layout: post
title: "Ruby Include vs Extend"
excerpt: "Whats the diff?"
tags: [Ruby]
comments: true
---

What is the difference between include and extend in Ruby? This is something that I've read a few times but forget shortly thereafter so I'm hoping this blog post will be enough for it to stick forever.

The main difference from what I've read is that Include is for making methods in a module accessible inside a class as instance variables. So basically when you include a module all of the instances of that class will have access to those methods.

Extend however, makes those methods into Class methods. Meaning they are not available for the instances of that class, only for the class itself.

Let's just look at an example to make this more clear.

``` ruby

module Thing

  def things
    puts "These are all the things"
  end
end

class Thang
  include Thing
end

my_thang = Thang.new
my_thang.things #=> These are all the things

Thang.things #=> NoMethodError => Why? Because we're calling it as a class method but include turns the Thing methods into intance methods.

class Thung
  extend Thing
end

my_thing = Thung.new
my_thing.things #=> NoMethodError => Why? Because we're calling it as an instance method, but extend makes the Thing methods into Class methods.

Thung.things #=> These are all the things

```

Hopefully these examples clear things up.

TLDR:
extend  => class methods
include => instance methods


text:
---
layout: default
---

# 1996-11-18 - BIS_sez

## Header Data

From: John Young<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 162338f9e6fc8532c6246a9700d15367fb4cbf531b83408944584a9139a19b48

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1996-11-18 18:00:09 UTC

Raw Date: Mon, 18 Nov 1996 10:00:09 -0800 (PST)

## Raw message

```
{% raw  %}From: John Young<EMAIL_ADDRESS>Date: Mon, 18 Nov 1996 10:00:09 -0800 (PST)
To<EMAIL_ADDRESS>Subject: BIS_sez
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

   11-18-96. FiTi:

   "Electronic money threat to central banks"

      A report issued today by the BIS says that innovations
      such as "electronic purses" or "digital cash" used over
      the Internet could erode central banks' income.
      "However, if issuance of e-money is limited to banks,
      the regulatory framework already in place can be
      extended to cover the new products, but competition and
      innovation might be more limited."

   -----

   http://jya.com/bissez.txt

   BIS_sez

{% endraw %}
```

## Thread

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

+ Return to "[John Young <jya@pipeline.com>](/authors/john_young_jya_at_pipeline_com_)"

+ 1996-11-18 (Mon, 18 Nov 1996 10:00:09 -0800 (PST)) - BIS_sez - _John Young<EMAIL_ADDRESS>

gha_license_id: MIT


text:
# UPPlatform_Python_SDK
Python SDK for the [Jawbone UP API](https://jawbone.com/up/developer/)

***The SDK is still under active development, so expect frequent changes.***

This SDK provides an object-oriented interface for working with the UP APIs. The UP APIs provide an OAuth2 workflow for accessing protected resources, so this SDK makes heavy use of the [oauth2client](https://oauth2client.readthedocs.io/en/latest/) package (which makes life super easy).

## Getting Started
### Register your application
Visit the [UP Developer Portal](https://jawbone.com/up/developer/) and click [Sign In](https://jawbone.com/up/developer/auth/login) to login with your UP account (or to create a new account).

Once you have signed in, you can create a new application by clicking the **Create App** button on your [account page](https://jawbone.com/up/developer/account). Fill out the form with the specific details for your application. If you don't know what to put for the URLs, review the [Authentication documentation](https://jawbone.com/up/developer/authentication).

### Install the SDK
The SDK exists on [pypi](https://pypi.python.org/pypi/upapi), so the easiest way to install it is to use pip:
```bash
pip install upapi
```

### Initialize the SDK
```python
import upapi
import upapi.scopes

upapi.client_id = <Client Id>
upapi.client_secret = <App Secret>
upapi.redirect_uri = <OAuth redirect URL>
upapi.scope = [upapi.scopes.<Scope0>, upapi.scopes.<Scope1>,...]
upapi.credentials_storage = <Storage object>
```

You can find your **Client Id** and **App Secret** in your Application Details (click on your app in the bottom left of the nav on the UP Developer Portal).

**OAuth redirect URL** must be one of the URLs you specified when creating your application. If you have multiple URLs, you can change the value of ```upapi.redirect_uri``` as necessary.

The [```upapi.scopes```](https://github.com/Jawbone/UPPlatform_Python_SDK/blob/master/upapi/scopes.py) module provides a list of all the available scopes. You can find scope definitions in the [UP API Authentication documentation](https://jawbone.com/up/developer/authentication).

Set ```upapi.credentials_storage``` to an instance of [oauth2client.client.Storage](http://oauth2client.readthedocs.io/en/latest/source/oauth2client.client.html#oauth2client.client.Storage) to ensure tokens/credentials get saved when automatically refreshed. For more details, refer to the [Automatic Refresh and Storage Objects](#automatic-refresh-and-storage-objects) section.

#### Token vs. Credentials
In this context, a token is the access token returned by the [UP Authentication APIs](https://jawbone.com/up/developer/authentication) during the OAuth flow.

Credentials on the other hand refers to the [oauth2client.client.OAuth2Credentials](https://oauth2client.readthedocs.io/en/latest/source/oauth2client.client.html#oauth2client.client.OAuth2Credentials) object that the oauth2client library creates when using the library to retrieve the access token.

## Authentication
The UP API uses OAuth2 to grant access to user data. For details, please read the [Authentication documentation](https://jawbone.com/up/developer/authentication).

### New Users
The first thing any application will need to do is have a user authenticate in the UP system and grant access to UP data. With the SDK,  this is a two step process:

1. Redirect the user to an app-specific login screen.
1. Convert a temporary authorization code into an access token.

#### Redirect to login
The SDK provides a helper function to generate an application-specific UP login URL.
```python
url = upapi.get_redirect_url()
```

#### Get the access token and/or credentials
After the user grants access to your application, the UP API redirects the user back to the URL you specified with an **authorization_code**. You then need to exchange this code for an access token. Pass the entire URL to the ```get_token``` function to do this. Additionally, the ```get_token``` function will create a **credentials** object based on the access token. You can retrieve the credentials object from the ```upapi.credentials``` parameter.
```python
token = upapi.get_token(url)
credentials = upapi.credentials
```

### Returning Users
Once a user has granted your application access to UP data, you can save the access token or credentials object for re-use on subsequent interactions with the UP API.

#### Set Credentials (or Token)
After you have initialized the SDK according to the instructions above, all you need to do is set the value of the ```credentials``` parameter.
```python
upapi.credentials = <credentials>
```
The SDK uses a credentials object rather than the token directly because the credentials object automatically tracks token expiration rather than requiring your application to handle it manually. However, if you would prefer to only interact with tokens, you can use the following helper functions, which will set/get an access token to/from the credentials object:
```python
upapi.set_access_token(<token>)
token = upapi.get_access_token()
```

Note: if this is the same session in which you authenticated this user, the SDK will automatically set the value of ```upapi.credentials``` when you call ```upapi.get_token```.

#### Refreshing Tokens/Credentials
The UP API OAuth2 tokens will expire after one year, so you will need to refresh them. Luckily, the SDK will refresh them for you automatically. Whenever the UP APIs return a ```401 Unauthorized``` response, the SDK will make two attempts to refresh the token and credentials. After refresh, the old values will stop working, so you should save the new ones for future requests.

##### Automatic Refresh and Storage Objects
Automatic token/credentials refresh occurs in the internal workings of the SDK, and the only way to know that a refresh occurred is to see if the value has changed. Rather than doing this manually, you can create a *Storage* object and assign it to ```upapi.credentials_storage```.
```python
upapi.credentials_storage = <Storage object>
```
When a Storage object exists, the SDK will use it to save the credentials whenever they are automatically refreshed. For more details on how to create a Storage object, refer to the [Storage documentation](https://developers.google.com/api-client-library/python/guide/aaa_oauth#storage).

##### Manual Refresh
You can always manually refresh tokens by calling ```upapi.refresh_token```:
```python
token = upapi.refresh_token()
```
This will use the existing value of ```upapi.credentials``` to return a new token as well as update ```upapi.credentials```.

#### Disconnecting Users
In certain instances, you will need to disconnect a user from your application and the UP API. The [Disconnection documentation](https://jawbone.com/up/developer/disconnection) provides details on when and how this can happen.
```python
upapi.disconnect()
```
This will use the existing value of ```upapi.credentials``` to send a disconnection request to the API and then clear the value of ```upapi.credentials```.

## User
The SDK creates [```User```](https://github.com/Jawbone/UPPlatform_Python_SDK/blob/master/upapi/user/__init__.py#L11) objects to represent the data available from the [User endpoint](https://jawbone.com/up/developer/endpoints/user). The easiest way to get the current user's object is to initialize the SDK and then run:
```python
user = upapi.get_user()
```
The ```data``` key of the User endpoint response gets converted from JSON into members of the newly created user object. The example response from the documentation would become:
```python
>>> user.xid
u'6xl39CsoVp2KirfHwVq_Fx'
>>> user.first
u'James'
>>> user.last
u'Franklin'
```

Remember that the amount of user data available depends on the scope--```basic_read``` vs. ```extended_read```--the user granted access.

### Friends
You can retrieve a user's friends list by accessing the ```friends``` property of the user object. ```friends``` is an object that contains the ```size``` of the friends list and the list itself under ```items```. Each element of the ```items``` list is a [```Friend```](https://github.com/Jawbone/UPPlatform_Python_SDK/blob/master/upapi/user/friends.py#L21) object.
```python
>>> friends = user.friends
>>> friends.size
2
>>> friends.items[1].xid
u'VkzWpOaqgeX'
```

If you ever need to renew a user's friends list, you can simply call ```get_friends```. This method will both return the latest friends list and set the ```friends``` property on the ```User``` object.
```python
>>> friends = user.friends
...
#something changes the friends list
...
>>> new_friends = user.get_friends()
>>> new_friends == user.friends
True
```

## UpApi
All the SDK objects that represent the API [Endpoints](https://jawbone.com/up/developer/endpoints) inherit from [```UpApi```](https://github.com/Jawbone/UPPlatform_Python_SDK/blob/master/upapi/__init__.py) objects to manage the OAuth connection and issue all requests to the UP API. If you want to manually manage the connections, requests, and objects, you can create ```UpApi``` (or any other) objects directly.

### Meta
All of the UP API endpoint responses contain a ```meta``` key that describes the response itself. All SDK objects convert this JSON to a [```Meta```](https://github.com/Jawbone/UPPlatform_Python_SDK/blob/master/upapi/meta.py) object. You can access the members of this object through the ```meta``` member. For example, here's how you would access ```meta``` data in a user object:
```python
>>> user.meta.user_xid
u'6xl39CsoVp2KirfHwVq_Fx'

>>> user.meta.code
200
```

## What's next?
The next steps for the SDK will be to add the remaining objects that represent each of the [resources in the UP API](https://jawbone.com/up/developer/endpoints).

For now, if you would like to use the SDK, you can establish the OAuth connection according to the instructions above. Then, you can issue requests through the ```UpApi``` object's ```http``` attribute, which is an instance of ```httplib2.Http```.
```python
up = upapi.UpApi()
resp, content = up.http.request('https://jawbone.com/nudge/api/v.1.1/users/@me/workouts', 'GET')
```

## Help!
If you have questions about the SDK or the UP API, check out the [docs](https://jawbone.com/up/developer/).

Can't find the answer, ask a question on [Stack Overflow using the jawbone tag](http://stackoverflow.com/questions/tagged/jawbone)

Still need help? Email apisupport @ jawbone.com

gha_language: Python


text:
# JokeBox - CLI App
A simple CLI CRUD app created with Ruby and ActiveRecord that allows a user to interact with silly jokes!

## Table of Contents
* General Info
* Technologies
* Setup
* Features
* Inspiration
* Contributions

## General Info
This project was created by Haleigh Dalke and Scott Espinosa for the purpose of learning Ruby and ActiveRecord. Mod1 Final Project at Flatiron School, presented on June 18, 2020.

Repo link: https://github.com/haleighdalke/jokebox

## Technologies
* Ruby version: 2.6.1
* ActiveRecord
* Sqlite3

## Setup
To run this project, please run the following in your terminal:
```
$ cd ./jokebox     # be sure you're in this file directory
$ bundle install   # install necessary gems
$ rake play        # begin the program
```
You should see a welcome message... happy laughing!

## Features
* Login as new user or returning user
* Select an option from Main Menu
    - **Create a joke** (prompts for joke setup, punchline, and topic. Prompts to save before returning to main menu)
    - **Discover jokes** (redirects to secondary menu, see below)
    - **Edit a joke** (prompts to search for joke and then allows you to edit the setup, punchline, and topic)
    - **Delete a joke** (prompts to search for joke, then deletes if found)
    - **Quit** (exits program)
* Select an option from secondary **Discover Jokes** Menu
    - **Find jokes by a user** (prompts for username, then returns jokes by user)
    - **Find jokes by topic** (prompts for topic name, then returns jokes by that topic)
    - **Rate a random joke** (provides a random joke and prompts for a rating)
    - **Get top five rated jokes** (sorts jokes by ratings, returns top 5 rated)
    - **Get all jokes** (prompts for a limit number, then returns that many jokes)
    - **Return to main menu** (returns to Main Menu)
* ASCII Art Welcome & Goodbye

## Inspiration
We started with the idea of a fake news app (apropos with our current political climate, right?) and landed on something a little more simple with a goal of keeping it light and making people laugh. Scott came up with the idea of a joke generating app and we built it together from there.

## Contributions
[ ] Haleigh Dalke
[ ] Scott Espinosa
[ ] https://github.com/15Dkatz/official_joke_api

If you want to contribute to our project, please see our CODE_OF_CONDUCT.md file for direction.

## License
Refer to LICENSE file.

repository: sfespinosa/jokebox

repo_name: sfespinosa/jokebox


text:
# README #

GREngine 3D Advanced Graphical Engine.

### What is GREngine? ###

GREngine is a 3D graphical engine, built for programmers that want the best solution for your dreams, like me, but is in development.

### How do I get set up? ###

First, download and install Java3D 1.5.2 library from Oracle, and then, download GREngine in it's lastest release, and setup it as default library for your Java code. And go coding! Your GREngine development environment is totally installed!
An other specialized environment it's being developed for more general applications, but with a cost!

### How I can learn GREngine? ###

I am developing a Javadoc and a text document for learning from basics to the more advanced of the version. Please wait for!

license: Unlicense

repository: VTHMgNPipola/GREngine

gha_language: Java

repo_name: VTHMgNPipola/GREngine


text:
Flask Style Tiles
=================

Scaffold for [Style Tiles](http://styletil.es) presentation project, built on [KL[AS] Flask](http://github.com/kylelarkin/flask) using [Middleman](http://middlemanapp.com)

Installation
------------

1. Prerequisites: Ruby (Bundler, Rake), Bower
2. Clone repository
3. `cd` into repository and run `bundle install`
3. Run `rake init`

Useage
------

#### `rake init`

- Bootstraps your project folder by running `bower install`, and installing bourbon and neat (for scss).
- Prompts for the project name, and saves that in `data/project.json` for use by the layout files
- Automatically calls `rake new`

#### `rake new`

- Creates a scaffold for a new style tile iteration
- If this is the first time (e.g. when called by `rake init`), this will create index.html.erb and _index.scss files. All other times it will create corresponding incremented version files.
- All styletile iteration files are automagically linked and ready to edit

#### To change the template .html.erb and .scss files

- Edit them in `templates/`

#### Middleman tl;dr

- Run `bundle exec middleman` to spawn a live-reloaded web server at `http://localhost:4567`
- Run `bundle exec middleman build` to package your site into static files (for deployment) within a `build` directory
- [Middleman Documentation](http://middlemanapp.com)

repository: astockwell/flask-style-tiles

repo_name: astockwell/flask-style-tiles


text:
# FTP-ts

FTP-ts is an FTP client module for [node.js](http://nodejs.org/) that provides an asynchronous interface for communicating with a FTP server.

It is a rewritten version of the [ftp package](https://github.com/mscdex/node-ftp/) from `mscdex`.

## Requirements

[node.js](http://nodejs.org/) -- v8.0 or newer

Note: For node version < 10, one of the `--harmony_async_iteration` or `--harmony` flags must be used.

## Install

    npm install ftp-ts

## Examples

### Get a directory listing of the current (remote) working directory

```javascript
  import Client from "ftp-ts";

  // connect to localhost:21 as anonymous
  Client.connect({host: "<IP_ADDRESS>", port: 21}).then(async (c) => {
    console.dir(await c.list());
    c.end();
  });
```

### Download remote file 'foo.txt' and save it to the local file system

```javascript
  import Client from "ftp-ts";
  import { createWriteStream } from "fs";

  // connect to localhost:21 as anonymous
  Client.connect({host: "<IP_ADDRESS>", port: 21}).then(async (c) => {
    const stream = await c.get('foo.txt');
    stream.pipe(createWriteStream('foo.local-copy.txt'));
    c.end();
  });
```

### Upload local file 'foo.txt' to the server

```javascript
  import Client from "ftp-ts";

  // connect to localhost:21 as anonymous
  Client.connect({host: "<IP_ADDRESS>", port: 21}).then((c) => {
    c.put('foo.txt', 'foo.remote-copy.txt');
    c.end();
  })
```

### Fallback to using PORT for data connections

```javascript
  import Client from "ftp-ts";

  // connect to localhost:21 as anonymous
  // Config PORT address and PORT range
  Client.connect({host: "<IP_ADDRESS>", port: 2111, portAddress: "<IP_ADDRESS>", portRange: "6000-7000"}).then(async (c) => {
    console.dir(await c.list());
    c.end();
  });
```

## Implementation

List of implemented required "standard" commands (RFC 959):
* [list](#ftplistpath-usecompression)
* [get](#ftpgetpath-usecompression)
* [put](#ftpputinput-destpath-usecompression)
* [append](#ftpappendinput-destpath-usecompression)
* [rename](#ftprenameoldpath-newpath)
* [logout](#ftplogout)
* [delete](#ftpdeletepath)
* [cwd](#ftpcwdpath-promote)
* [abort](#ftpabortimmediate)
* [site](#ftpsitecommand)
* [status](#ftpstatus)
* [ascii](#ftpascii)
* [binary](#ftpbinary)

List of implemented optional "standard" commands (RFC 959):
* [mkdir](#ftpmkdirpath-recursive)
* [rmdir](#ftprmdirpath-recursive)
* [cdup](#ftpcdup)
* [pwd](#ftppwd)
* [system](#ftpsystem)
* [listSafe](#ftplistSafepath-usecompression)

List of implemented extended commands (RFC 3659)
* [size](#ftpsizepath)
* [lastMod](#ftplastmodpath)
* [restart](#ftprestartbyteoffset)

## Class: FTP, default

### new FTP()

Creates a new FTP client.

### Class Method: FTP.connect([options])

* `options` [<Object>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object) See [ftp.connect](#ftpconnectoptions) for which options are available.
* Returns:         [<Promise<FTP>>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) The promise is resolved to a [FTP](#class-ftp-default).

### Event: 'greeting'

* [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) the text the server sent upon connection.

Emitted after connection.

### Event: 'ready'

Emitted when connection and authentication were sucessful.

### Event: 'close'

* [<boolean>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type) if closed becouse of error

Emitted when the connection has fully closed.

### Event: 'end'

Emitted when the connection has ended.

### Event: 'error'

* [<Error>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error) the error when an error occurs

Emitted when an error occurs. In case of protocol-level errors, the error contains a `code` property that references the related 3-digit FTP response code.

### Override: ftp.localPort(bindIp[, portRange])

* `bindIp`         [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) The IP to bind the `PORT` socket to.
* `portRange`      [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) The range of ports to use when setting up `PORT` sockets.
* Returns:         [<Promise<[string, string | number]>>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) The promise is resolved to the following object.
    * 0            [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) The `bindIp` to actually bind to.
    * 1            [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) The `portRange` or `portNumber` to bind to.

This method may be overridden on the instance to allow for better managed `PORT`/`EPRT` commands.

For example, you may wish to bind only to a specific network interface for security reasons.
In that case you may override this method to return the `bindIp` with a value of `<IP_ADDRESS>` instead of `<IP_ADDRESS>` to only allow incoming connections from localhost.

Another reason may be to decide upon a port number and `await` some NAT rules to propagate before the remote server connects.

This could also be useful if your external IP family does not match the family of your interface due to proxying or NAT rules.
By default the zero `bindIp` will always be in the same IP family as the external IP set as `portAddress` in the `IOption` object.

### ftp.connect([options])

* `options` [<Object>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object)
    * `host`         [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) The hostname or IP address of the FTP server. **Default:** `'localhost'`.
    * `port`         [<number>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type) The port of the FTP server. **Default:** `21`.
    * `portAddress`  [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) The external IP address for the server to connect to when using `PORT`.
    * `portRange`    [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) The range of ports to use when setting up `PORT` sockets.
    * `secure`       [<boolean>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type) | [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) Set to `true` for both control and data connection encryption, `'control'` for control connection encryption only, or `'implicit'` for implicitly encrypted control connection (this mode is deprecated in modern times, but usually uses port 990) **Default:** `false`.
    * `secureOptions` [<Object>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object) Additional options to be passed to [`tls.connect()`](https://nodejs.org/api/tls.html#tls_tls_connect_options_callback).
    * `user`         [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) Username for authentication. **Default:** `'anonymous'`.
    * `password`     [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) Password for authentication. **Default:** `'anonymous@'`.
    * `connTimeout`  [<number>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type) How long (in milliseconds) to wait for the control connection to be established. **Default:** `10000`.
    * `dataTimeout`  [<number>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type) How long (in milliseconds) to wait for a `PASV`/`PORT` data connection to be established. **Default:** `10000`.
    * `keepalive`    [<number>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type) How often (in milliseconds) to send a 'dummy' (NOOP) command to keep the connection alive. **Default:** `10000`.

Connects to an FTP server.

### ftp.end()

Closes the connection to the server after any/all enqueued commands have been executed.

### ftp.destroy()

Closes the connection to the server immediately.

### ftp.list([path[, useCompression]])

* `path`           [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) **Default:** current directory.
* `useCompression` [<boolean>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type) **Default:** `false`.
* Returns:         [<Promise<Object>>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) The promise is resolved to the following object.
    * type         [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) A single character denoting the entry type: `'d'` for directory, `'-'` for file (or `'l'` for symlink on **\*NIX only**).
    * name         [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) The name of the entry.
    * size         [<number>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type) The size of the entry in bytes.
    * date         [<Date>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) The last modified date of the entry.
    * rights       [<Object>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object) The various permissions for this entry **(*NIX only)**.
        * user     [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) An empty string or any combination of `'r'`, `'w'`, `'x'`.
        * group    [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) An empty string or any combination of `'r'`, `'w'`, `'x'`.
        * other    [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) An empty string or any combination of `'r'`, `'w'`, `'x'`.
    * owner        [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) The user name or ID that this entry belongs to **(*NIX only)**.
    * group        [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) The group name or ID that this entry belongs to **(*NIX only)**.
    * target       [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) For symlink entries, this is the symlink's target **(*NIX only)**.
    * sticky       [<boolean>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type) `true` if the sticky bit is set for this entry **(*NIX only)**.

Get a directory listing from the server.

### ftp.get(path[, useCompression])

* `path`           [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) The name of the file to retreive.
* `useCompression` [<boolean>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type) **Default:** `false`.
* Returns:         [<Promise<stream.Readable>>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) The promise is resolved to a [stream.Readable](https://nodejs.org/api/stream.html#stream_class_stream_readable).

Retrieves a file at `path` from the server.

### ftp.put(input, destPath[, useCompression])

* `input`          [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) | [<buffer>](https://nodejs.org/api/buffer.html#buffer_class_buffer) | [<stream.Readable>](https://nodejs.org/api/stream.html#stream_class_stream_readable) The file name as a string, the file content as a buffer, the file content as a stream.
* `destPath`       [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) The name of the file to write.
* `useCompression` [<boolean>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type) **Default:** `false`.
* Returns:         [<Promise>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)

Sends data to the server to be stored as `destPath`.

### ftp.append(input, destPath[, useCompression])

* `input`          [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) | [<buffer>](https://nodejs.org/api/buffer.html#buffer_class_buffer) | [<stream.Readable>](https://nodejs.org/api/stream.html#stream_class_stream_readable) The file name as a string, the file content as a buffer, the file content as a stream.
* `destPath`       [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) The name of the file to write.
* `useCompression` [<boolean>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type) **Default:** `false`.
* Returns:         [<Promise>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)

Sends data to the server to be stored as `destPath`, except if `destPath` already exists, it will be appended to instead of overwritten.

### ftp.rename(oldPath, newPath)

* `oldPath`        [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) The name of the file to move.
* `newPath`        [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) The new name of the file.
* Returns:         [<Promise>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)

Renames `oldPath` to `newPath` on the server.

### ftp.logout()

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

Logout the user from the server.

### ftp.delete(path)

* `path`           [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) The name of the file to delete.
* Returns:         [<Promise>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)

Deletes the file represented by `path` on the server.

### ftp.cwd(path[, promote])

* `path`           [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) The path to the new working directory.
* `promote`        [<boolean>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type) **Default:** `false`.
* Returns:         [<Promise<string | undefined>>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) The promise is resolved to a [string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) or [undefined](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Undefined_type).

Changes the current working directory to `path`.

### ftp.abort(immediate)

* `immediate`      [<boolean>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type) **Default:** `true`.
* Returns:         [<Promise>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)

Aborts the current data transfer (e.g. from get(), put(), or list()).

### ftp.site(command)

* `command`        [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) `SITE` command to send.
* Returns:         [<Promise>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) The promise is resolved to a tuple of a [number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type)  and an optional [string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type)

Sends `command` (e.g. 'CHMOD 755 foo', 'QUOTA') using SITE.

### ftp.status()

* Returns:         [<Promise<string>>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) The promise is resolved to a [string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type)

Retrieves human-readable information about the server's status.

### ftp.ascii()

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

Sets the transfer data type to ASCII.

### ftp.binary()

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

Sets the transfer data type to binary (default at time of connection).

### ftp.mkdir(path[, recursive])

* `path`           [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) The path to the new directory.
* `recursive`      [<boolean>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type) Is for enabling a 'mkdir -p' algorithm **Default:** `false`.
* Returns:         [<Promise>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)

Creates a new directory, `path`, on the server.

### ftp.rmdir(path[, recursive])

* `path`           [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) The path of the directory to delete.
* `recursive`      [<boolean>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type) Will delete the contents of the directory if it is not empty **Default:** `false`.
* Returns:         [<Promise>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)

Removes a directory, `path`, on the server.

### ftp.cdup()

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

Changes the working directory to the parent of the current directory.

### ftp.pwd()

* Returns:         [<Promise<string | undefined>>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) The promise is resolved to a [string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) when the server replies with a path.

Retrieves the current working directory.

### ftp.system()

* Returns:         [<Promise<string>>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) The promise is resolved to a [string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) when the server sends a reply.

Retrieves the server's operating system.

### ftp.listSafe([path[, useCompression]])

* `path`           [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) **Default:** current directory.
* `useCompression` [<boolean>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type) **Default:** `false`.
* Returns:         [<Promise<Object>>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) The promise is resolved to the following object.
    * type         [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) A single character denoting the entry type: `'d'` for directory, `'-'` for file (or `'l'` for symlink on **\*NIX only**).
    * name         [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) The name of the entry.
    * size         [<number>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type) The size of the entry in bytes.
    * date         [<Date>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) The last modified date of the entry.
    * rights       [<Object>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object) The various permissions for this entry **(*NIX only)**.
        * user     [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) An empty string or any combination of `'r'`, `'w'`, `'x'`.
        * group    [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) An empty string or any combination of `'r'`, `'w'`, `'x'`.
        * other    [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) An empty string or any combination of `'r'`, `'w'`, `'x'`.
    * owner        [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) The user name or ID that this entry belongs to **(*NIX only)**.
    * group        [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) The group name or ID that this entry belongs to **(*NIX only)**.
    * target       [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) For symlink entries, this is the symlink's target **(*NIX only)**.
    * sticky       [<boolean>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type) `true` if the sticky bit is set for this entry **(*NIX only)**.

Similar to list(), except the directory is temporarily changed to `path` to retrieve the directory listing. This is useful for servers that do not handle characters like spaces and quotes in directory names well for the LIST command. This function is "optional" because it relies on pwd() being available.

### ftp.size(path)

* `path`           [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) The path of the file.
* Returns:         [<Promise<number>>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) The promise is resolved to a [number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type)

Retrieves the size of `path`.

### ftp.lastMod(path)

* `path`           [<string>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) The path of the file.
* Returns:         [<Promise<date>>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise) The promise is resolved to a [date](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Date_type)

Retrieves the last modified date and time for `path`.

### ftp.restart(byteOffset)

* `byteOffset`     [<number>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type)
* Returns:         [<Promise>](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)

Sets the file byte offset for the next file transfer action (get/put) to `byteOffset`.

repository: lumphe/ftp-ts

gha_language: TypeScript

repo_name: lumphe/ftp-ts


text:
For changes to files under the `/model/` folder, and manual edits to autogenerated code (e.g. `/service/s3/api.go`) please create an Issue instead of a PR for those type of changes.

If there is an existing bug or feature this PR is answers please reference it here.

repository: aws/aws-sdk-go

branch_name: refs/heads/main

gha_language: Go

repo_name: aws/aws-sdk-go


text:
mustache-express4
=================

Mustache rendering engine for express4.

Usage
-----
Use like any other view engine.

    app.engine 'mustache', require 'mustache-express4'
    app.set 'view engine', 'mustache'
    app.set 'partials', __dirname + '/views/partials'


text:
# Release Notes - cell2cell v0.5.11

## New features
- Created a new function to use external communication scores, generated with other tools. This function can be found in
```cell2cell.tensor.external_scores.dataframes_to_tensor()```.
- Added ```cell2cell.tensor.tensor.BaseTensor.loc_nans```, ```cell2cell.tensor.tensor.BaseTensor.loc_zeros```, and same attributes in
heirs tensor classes to keep track of values assigned with NaNs and with real zeros, respectively.
- ```cell2cell.tensor.external_scores.dataframes_to_tensor()``` also incorporates the previous point to keep track
of NaNs and real zeros when using external communication scores.
- Added ```lr_fill``` and ```cell_fill``` parameters to ```cell2cell.tensor.external_scores.dataframes_to_tensor()```

## Feature updates
- Added two new options to the parameter ```how``` in ```cell2cell.tensor.build_context_ccc_tensor()```.
They are: ```how='outer_genes'``` and ```how='outer_cells'``` . These new options were also extended to all InteractionTensors
derived from ```cell2cell.tensor.tensor.BaseTensor```.
- These options of how were also extended to the new function ```cell2cell.tensor.external_scores.dataframes_to_tensor()```,
but here implemented as ```how='outer_lrs'``` and ```how='outer_cells'```.
- Implemented multiple to options to aggregate gene expression of protein complexes. Available options are using the
minimum expression or the average expression among the subunits. This can be controlled with the parameter
```complex_agg_method='min'``` or ```complex_agg_method='mean'``` when creating a ```cell2cell.tensor.InteractionTensor```,
```cell2cell.core.InteractionSpace```, ```cell2cell.analysis.BulkInteractions``` pipeline, or ```cell2cell.analysis.SingleCellInteractions``` pipeline.
- The previous point relies on the function ```cell2cell.preprocessing.rnaseq.add_complexes_to_expression()``` through
the parameter ```agg_method='min'``` or ```agg_method='mean'```
- Added parameter ```cbar_label``` to the function ```cell2cell.plotting.factor_plot.loading_clustermap()```
to personalize the title of the color bar.
- Added parameter ```manual_elbow``` to ```cell2cell.tensor.tensor.BaseTensor.elbow_rank_selection()``` to manually specify
the elbow to highlight.

## Fixed Bugs
- Renamed ```cell2cell.plotting.circos_plot``` into ```cell2cell.plotting.circular_plot``` to avoid incompatibility with
function ```cell2cell.plotting.circos_plot.circos_plot()``` that is directly imported under ```cell2cell.plotting```


text:
GeoSharerMod
=========
A Minecraft ForgeModLoader mod for sharing minecraft multiplayer map data. Tailored for use with Civcraft (http://www.civcraft.vg/).

How To Use
===========
Use Minecraft Forge and add the mod zip to your mods directory. The mod will automatically download overworld data from any multiplayer server you play on, and store it in a stripped down and compressed *.geosharer format in the mods/GeoSharer/[servername]/ directory.

These *.geosharer files can be shared with map-making collaborators to ensure that everyone has the most up to date world data. Each chunk is given a timestamp, which is used to synchronise data from multiple *.geosharer payloads.

To take the *.geosharer files and turn them into a world you need to use the GeoSharerMerge program.

Compiling
=========
The mod is compiled using Eclipse and Forge MCP for the relevant version of Minecraft. Version naming is kept in step with Minecraft, with appended letters for multiple releases withing a single version.

Source Directory Structure
==========================
All mod source files are in the base directory.

repository: TealNerd/GeoSharerMod

repo_name: TealNerd/GeoSharerMod


text:
[![](http://www.apache.org/images/asf-logo.gif)](http://www.apache.org/) [![](../images/struts.gif)]()

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

Last Published: 2008-11-29

[Apache](http://www.apache.org/) | [Struts 2](../2.x/) | [Struts 1](../1.x/)

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

##### Struts 1

-   [Welcome](../index.html.md)
-   [Learning](../learning.html.md)
-   [Roadmap](../roadmap.html.md)
-   [Releases](../downloads.html.md)

##### Documentation

-   [User Guide](../userGuide/index.html.md)
-   [FAQs and HOWTOs](../faqs/index.html.md)
-   [Release Notes](../userGuide/release-notes.html.md)
-   [Javadoc](../apidocs/index.html.md)
-   [DTDDoc](../dtddoc/index.html.md)

##### Support

-   [User Mailing List](../mail.html.md)
-   [Issue Tracker (JIRA)](http://issues.apache.org/struts/)
-   [Wiki Pages](http://wiki.apache.org/struts/)

##### Components

-   [Struts Apps](../struts-apps/index.html.md)
-   [Struts EL](../struts-el/index.html.md)
-   [Struts Extras](../struts-extras/index.html.md)
-   [Struts Faces](../struts-faces/index.html.md)
-   [Struts Scripting](../struts-scripting/index.html.md)
-   [Struts Taglib](../struts-taglib/index.html.md)
-   [Struts Tiles](../struts-tiles/index.html.md)

##### Project Documentation

-   [Project Information](../project-info.html.md)
-   [Project Reports](../project-reports.html.md)

[![Built by Maven](../images/logos/maven-feather.png)](http://maven.apache.org/ "Built by Maven")

Introduction
-------------------------------------------

This document contains the release notes for **Version 1.0.2** of the Struts Framework, and covers changes that have taken place since [Version 1.0.1](release-notes-1_0_1.html.md) was released. The following sections cover [New Features](#New) and [Changes](#Changes) to Struts.

This version covers bug-fixes only; no new functionality.

What's Included?
-------------------------------------------------

The binary distribution of this release includes the following files relevant to Struts 1.0.2:

-   `INSTALL` - Brief installation instructions. See the `Struts Documentation Application` , or online at <http://jakarta.apache.org/struts/> for more information.
-   `LICENSE` - The Apache Software Foundation license that defines the terms under which you can use Struts (and other software licensed by Apache).
-   `README` - A brief introduction to Struts.
-   `lib/` - Directory containing files you will need in your own applications. The individual files of interest are:
    -   `struts.jar` - JAR file that contains the compiled Java classes for version 1.0.2 of Struts. You must place this file in the `/WEB-INF/lib` directory of your web application.
    -   `struts-xxxxx.tld` - The tag library descriptor files for the Struts 1.0.2 tag libraries (bean,.html.md, logic, and template). You must place these files in the `/WEB-INF` directory of your web application, and reference them with appropriate `<taglib>` directives in your web.xml file.
    -   `jdbc2_0-stdext.jar` - The JDBC 2.0 Optional Package API classes (package `javax.sql` ). You will need to include this file in the `/WEB-INF/lib` directory of your application, if it is not already made visible to web applications by your servlet container.
    -   `struts-config_1_0.dtd` - The document type descriptor (DTD) for the Struts configuration file (which is typically named `/WEB-INF/struts-config.xml` . Your configuration file will be validated against an internal copy of this DTD -- this copy is available for reference purposes only.
    -   `web-app_2_2.dtd` - The document type descriptor (DTD) for web.xml files conforming to the Servlet 2.2 specification. This copy is for reference purposes only.
    -   `web-app_2_3.dtd` - The document type descriptor (DTD) for web.xml files conforming to the Servlet 2.3 specification. This copy is for reference purposes only.
-   `webapps/` - Web Application Archive (WAR) files for the web applications that are included with Struts.

The struts 0.5 milestone API release is no longer supported, and will be removed as of Struts 1.1.

What's New?
---------------------------------------

No new features have been added in this release.

Changes and Bug Fixes
-------------------------------------------------------------

The following changes and bug fixes have occurred in the basic controller framework (package `org.apache.struts.action` ):

-   The `ActionForm.getMultipartRequestHandler()` method is now public rather than protected, to restore compatibility with the Tiles extension.

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

© 2000-2008 Apache Software Foundation

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


text:
---
title: "Baofeng UV-5R - Getting Started"
date: 2019-06-04T10:43:05-02:00
draft: false
tags: ["radio", "amateur", "baofeng", "antenna"]
topics: []
description: ""
---

## Baofeng UV-5R

A cheap beginner dual-band handheld with enough features to be useful. Lots of extensive reviews exist, so Ill just touch on my limited use case.

[This kit][2] is the one I started with which includes a spare battery, whip antenna, programming cable, and "other stuff". Good value for what is included.

## Antennas and Accessories

The stock UV-5R antenna is useable, but many options exist to support specific use cases.

#### Baofeng SMA-to-BNC Adapters

[BNC-to_SMA Adapters][1]. Cheap, easy, no brainer kit addition.

#### Longer Range Whip

[This particular whip][3] came in the above-mentioned kit and fits the UV-5R very well, with a good seal when finger-tight. Performance while hiking has been acceptable in the Santa Cruz mountains, but I havent compared it to others. Some of the critical Amazon reviews may warrant another look at some better options. Antenna is very "whippy", so not convenient when clipping the radio onto a pocket.

#### Shorter Range Stubby

Not good option: [The official Baofeng stubby][4] was an acceptable build quality, but when screwed on did not seal to the radio body. It left a gap of brassy threads just begging for grit and junk to work in.

Great option (albeit pricey): [Diamond RHF10 (BNC)][5] This antenna can be found for about $20, if you look. Since it fits to the BNC adapters, and the adapters fit very well with the UV-5R, there are no gaps when this is mounted. Build quality is quite high, a bit weightier than the Baofeng, with acceptable performance you would expect from a shorter range antenna. Easily fits in a pocket, making for a compact "field coordination" handheld.

#### Zipper/Molle Pouch

Always preferable to keep bits and pieces organized, a zipper pouch works exceedingly well.

[This pouch][6] (or any like it of a similar size) has an interior sleeve where I stow spare batteries, with some extra protection for the contacts. The UV-5R cradle and power supply fit in here, SMA adapters, stubby and medium-length whips, PTT accessories, programming cable.. hard to think of what wont fit. Keep all the bits you might need all in once place.

[1]: https://www.amazon.com/gp/product/B00CVQK466/
[2]: https://www.amazon.com/gp/product/B0772FYKK8/
[3]: https://www.amazon.com/dp/B076DZR8KP/
[4]: https://www.amazon.com/gp/product/B00M8QVJ5O/
[5]: https://www.gigaparts.com/diamond-antenna-rhf10.html
[6]: https://www.amazon.com/Orca-Tactical-MOLLE-Medical-Utility/dp/B015QHZBE6/


text:
# Speedtest

[![Docker Pulls](https://img.shields.io/docker/pulls/openspeedtest/latest?style=flat-square&color=607D8B&label=docker%20pulls&logo=docker)](https://hub.docker.com/r/openspeedtest/latest)
[![GitHub Stars](https://img.shields.io/github/stars/openspeedtest/Speed-Test?style=flat-square&color=607D8B&label=github%20stars&logo=github)](https://github.com/openspeedtest/latest)
[![Compose Templates](https://img.shields.io/static/v1?style=flat-square&color=607D8B&label=compose&message=templates)](https://github.com/GhostWriters/DockSTARTer/tree/master/compose/.apps/openspeedtest)

## Description

[OpenSpeedTest](https://github.com/openspeedtest/Speed-Test) is a self-hosted speed test service which is useful for testing the connection speed to your server.

repository: GhostWriters/DockSTARTer

gha_language: Shell

repo_name: GhostWriters/DockSTARTer


text:
# Utilities

This page contains references to the utility repos and projects developed under the dr4 foundation. It also contains 3rd party utilities that may be used to develop dr4 software.

## `C/C++`

Here are the `C` and `C++` related utilities:

### `pack-string`

[Repo Link](https://github.com/dr4f/pack-string)

`pack-string` is a C++ library that helps to easily and effeciently pack C++ objects into binary strings and formatted binary strings.


text:
#### Scripts
##### New: CheckFieldValue
- This script checks that a field exists (and contains data), and optionally checks the value of the field for a match against an input value. If a regex is not supplied, the script checks that the field is not empty. This script can be used with the "GenericPolling" playbook to poll for field population or that a field contains a specific value.

repository: demisto/content

repo_name: demisto/content


text:
# Publish control

This repo provides code samples for publish control feature set of [Nimble Streamer](https://softvelum.com/nimble/).

Take a look at feature overview in this article: https://blog.wmspanel.com/2015/10/rtsp-publish-control-framework-overview.html

This article gives more details on publish control usage: https://blog.wmspanel.com/2015/12/rtsp-publish-control-setup.html

Publish control can be used for controlling streams from end-user mobile devices, like streaming from Larix Broadcaster application or other app: https://softvelum.com/larix/


text:
# 6tisch/sixtop

6top Example Description
------------------------

By default, the code will operate in the role of a regular RPL+TSCH node.
Change the value of `is_coordinator` variable at startup to put it in TSCH coordinator mode.

6top Operation
---------------

If the mode is not in the TSCH coordinator mode:

* The application triggers a 6P Add Request to 6dr (neighbor)
* Following this the application triggers another 6P Add Request to 6dr
* After an interval, the application triggers a 6P Delete Request to 6dr

For the Cooja simulation, you may use the rpl-tsch-sixtop-cooja.csc file in this folder.
Once you run the simulation, "Mote output" window of Cooja simulator displays the
following messages.

For a 6P Add transaction,
		ID:1 TSCH-sixtop: Sixtop IE received
		ID:1 TSCH-sixtop: Send Link Response to node 2
		ID:2 TSCH-sixtop: Sixtop IE received
		ID:2 TSCH-sixtop: Schedule link x as RX with node 2
		ID:2 TSCH-sixtop: Schedule link x as TX with node 1

Similarly for a 6P Delete transaction.

repository: contiki-ng/contiki-ng

branch_name: refs/heads/develop

gha_language: C

repo_name: contiki-ng/contiki-ng


text:
This file should outline your agreements on
[pull request workflow](#pull-request-workflow) and [code review
workflow](#code-review-workflow), including who merges pull requests,
and [code style](#code-style).
##### Code Style
For the **final project**, you can choose your own code
style and pull-request workflow.

For the *group project*, use
- Styleguides
	- [AirBnB Ruby Styleguide](https://github.com/airbnb/ruby)
	- [AirBnB JavaScript Styleguide](https://github.com/airbnb/javascript)
- The code reviewer merges pull requests

repository: morganmccrory/house-rules

repo_name: morganmccrory/house-rules


text:
---
layout: layout.pug
navigationTitle:
excerpt: API reference for DC/OS Apache Kafka
title: API Reference
menuWeight: 90
model: /mesosphere/dcos/services/kafka/data.yml
render: mustache
---

#include /mesosphere/dcos/services/include/api-reference.tmpl

# Topic Operations

These operations mirror what is available with `bin/kafka-topics.sh`.

## List Topics

```bash
dcos {{ model.packageName }} --name={{ model.serviceName }} topic list
[
  "topic1",
  "topic0"
]
```

```bash
curl -H "Authorization: token=$auth_token" "<dcos_url>/service/{{ model.serviceName }}/v1/topics"
[
  "topic1",
  "topic0"
]
```

## Describe Topic

```bash
dcos {{ model.packageName }} --name={{ model.serviceName }} topic describe topic1
{
  "partitions": [
  {
    "0": {
      "controller_epoch": 1,
      "isr": [
        0,
        1,
        2
      ],
      "leader": 0,
      "leader_epoch": 0,
      "version": 1
    }
  },
  {
    "1": {
      "controller_epoch": 1,
      "isr": [
        1,
        2,
        0
      ],
      "leader": 1,
      "leader_epoch": 0,
      "version": 1
    }
  },
  {
    "2": {
      "controller_epoch": 1,
      "isr": [
        2,
        0,
        1
      ],
      "leader": 2,
      "leader_epoch": 0,
      "version": 1
    }
  }
  ]
}
```

```bash
curl -X POST -H "Authorization: token=$auth_token" "<dcos_url>/service/{{ model.serviceName }}/v1/topics/topic1"
{
  "partitions": [
  {
    "0": {
      "controller_epoch": 1,
      "isr": [
        0,
        1,
        2
      ],
      "leader": 0,
      "leader_epoch": 0,
      "version": 1
    }
  },
  {
    "1": {
      "controller_epoch": 1,
      "isr": [
        1,
        2,
        0
      ],
      "leader": 1,
      "leader_epoch": 0,
      "version": 1
    }
  },
  {
    "2": {
      "controller_epoch": 1,
      "isr": [
        2,
        0,
        1
      ],
      "leader": 2,
      "leader_epoch": 0,
      "version": 1
    }
  }
  ]
}

```

## Create Topic

```bash
dcos {{ model.packageName }} --name={{ model.serviceName }} topic create topic1 --partitions=3 --replication=3
{
  "message": "Output: Created topic \"topic1\"\n"
}
```

```bash
curl -X POST -H "Authorization: token=$auth_token" "<dcos_url>/service/{{ model.serviceName }}/v1/topics/topic1?partitions=3&replication=3"
{
  "message": "Output: Created topic \"topic1\"\n"
}
```

## View Topic Offsets

There is an optional `--time` parameter which may be set to either "first", "last", or a timestamp in milliseconds as described in the [{{ model.techShortName }} documentation](https://kafka.apache.org/documentation/#topicconfigs).

```bash
dcos {{ model.packageName }} --name={{ model.serviceName }} topic offsets topic1 --time=last
[
  {
    "2": "334"
  },
  {
    "1": "333"
  },
  {
    "0": "333"
  }
]
```

```bash
curl -H "Authorization: token=$auth_token" "<dcos_url>/service/{{ model.serviceName }}/v1/topics/topic1/offsets?time=-1"
[
  {
    "2": "334"
  },
  {
    "1": "333"
  },
  {
    "0": "333"
  }
]
```

## Alter Topic Partition Count

```
dcos {{ model.packageName }} --name={{ model.serviceName }} topic partitions topic1 2
{
  "message": "Output: WARNING: If partitions are increased for a topic that has a key, the partition logic or ordering of the messages will be affectednAdding partitions succeeded!n"
}
```

```bash
curl -X PUT -H "Authorization: token=$auth_token" "<dcos_url>/service/{{ model.serviceName }}/v1/topics/topic1?operation=partitions&partitions=2"
{
  "message": "Output: WARNING: If partitions are increased for a topic that has a key, the partition logic or ordering of the messages will be affectednAdding partitions succeeded!n"
}
```

## Run Producer Test on Topic

```
dcos {{ model.packageName }} --name={{ model.serviceName }} topic producer_test topic1 10
{
  "message": "10 records sent, 70.422535 records/sec (0.07 MB/sec), 24.20 ms avg latency, 133.00 ms max latency, 13 ms 50th, 133 ms 95th, 133 ms 99th, 133 ms 99.9th.n"
}
```
```bash
curl -X PUT -H "Authorization: token=$auth_token" "<dcos_url>/service/{{ model.serviceName }}/v1/topics/topic1?operation=producer-test&messages=10"
{
  "message": "10 records sent, 70.422535 records/sec (0.07 MB/sec), 24.20 ms avg latency, 133.00 ms max latency, 13 ms 50th, 133 ms 95th, 133 ms 99th, 133 ms 99.9th.n"
}
```

The above commands run the equivalent of the following command from the machine running the {{ model.techShortName }} Scheduler:

```bash
kafka-producer-perf-test.sh \
  --topic <topic> \
  --num-records <messages> \
  --throughput 100000 \
  --record-size 1024 \
  --producer-props bootstrap.servers=<current broker endpoints>
```

## Delete Topic

```bash
dcos {{ model.packageName }} --name={{ model.serviceName }} topic delete topic1
{
  "message": "Topic topic1 is marked for deletion.nNote: This will have no impact if delete.topic.enable is not set to true.n"
}
```

```bash
curl -X DELETE -H "Authorization: token=$auth_token" "<dcos_url>/service/{{ model.serviceName }}/v1/topics/topic1"
{
  "message": "Topic topic1 is marked for deletion.nNote: This will have no impact if delete.topic.enable is not set to true.n"
}
```

NOTE: Note the warning in the output from the commands above. You can change the indicated `delete.topic.enable` configuration value as a configuration change.

## List Under Replicated Partitions

```bash
dcos {{ model.packageName }} --name={{ model.serviceName }} topic under_replicated_partitions
{
  "message": ""
}
```

```bash
curl -H "Authorization: token=$auth_token" "<dcos_url>/service/{{ model.serviceName }}/v1/topics/under_replicated_partitions"
{
  "message": ""
}
```

## List Unavailable Partitions

```bash
dcos {{ model.packageName }} --name={{ model.serviceName }} topic unavailable_partitions
{
  "message": ""
}
```

```bash
curl -H "Authorization: token=$auth_token" "<dcos_url>/service/{{ model.serviceName }}/v1/topics/unavailable_partitions"
{
  "message": ""
}
```

repository: mesosphere/dcos-docs-site

gha_language: SCSS

repo_name: mesosphere/dcos-docs-site


text:
Twoblocks

  Free and open source 2fa manager built with Stacks

## 🚀 Features

- Codes are synced between devices
- Use your phone / laptop camera to scan a qrcode
- Add an account manually
- Dark theme
- Data stored encrypted on the storage of your choice using Stacks

## 📚 Setup

First you need to clone the repository:

```sh
git clone git@github.com:pradel/twoblocks.git
```

Then run the following command to install dependencies:

```sh
yarn install
```

Finally to start the server run:

```sh
yarn start
```

You can now open your browser and go to http://localhost:3000 to see the app.

## ☝ Feature requests, suggest changes

Open an issue on this repo :)

## 📖 License

MIT © [Léo Pradel](https://www.leopradel.com/)

repository: pradel/twoblocks

repo_name: pradel/twoblocks


text:
---
layout: academy_post
title: Optimize Your Meteor App for Oplog Integration
permalink: /academy/optimize-your-app-for-oplog
---

[Oplog integration](https://github.com/meteor/meteor/wiki/Oplog-Observe-Driver) gives a huge performance boost for Meteor apps, and it's recommend to use oplog with every production Meteor app. MongoHQ makes it super easy with their affordable MongoDB elastic scaling service.

Meteor supports most of the queries with oplog, but there are some edge cases where observers will fall back into an inefficient poll and diff implementation. It's very hard to implement oplog support for those queries unless MongoDB supports built-in observing functionality.

Therefore, some of the queries in your app may fail to use oplog even if you've integrated oplog support into your app. I will show what those unsupported queries are and how to identify them easily.

> Meteor has completed adding major features to its oplog integration in Meteor version 0.7.2. Thus, this article applies if you are using Meteor version 0.7.2 or higher.

## When You can't Use Oplog

Let me show you those edge cases in which oplog support cannot be enabled.

 See below:

~~~js
Posts.find({category: "meteor"}, {limit: 10});
~~~

If you add a sort specifier, you can simply get rid of this issue.

### Unsupported Operators

Meteor’s oplog integration does not support the `$where` operator or any geo–location specific operators. Therefore, you will need to find an alternative if you require oplog support for those queries.

### Unsupported Projections

Meteor’s oplog integration relies on MiniMongo for projections. MiniMongo does not support all of the projection operators. One such operator is `$elemMatch`. If you are using such operators in your query, your query won't receive the oplog support.

### Invalid Selectors

Sometimes, it's possible to have invalid selectors in some of your queries. This may be the result of some runtime behavior. For an example, check out following code:

~~~js
var remainder = getConfig('remainder');
Posts.find({users: {$mod: [10, remainder]}})
~~~

Due to a runtime error, it is possible to have the remainder listed as `null`. MiniMongo requires the `$mod` array to be filled with two numbers; therefore, oplog support won't be enabled for the above query.

### Unsupported Sort Operators

Oplog implementation relies on MiniMongo for the sorting behavior. Again, MiniMongo does not support all of MongoDB's sorting operators and features. If you use any unsupported feature, your observer can't take advantage of the oplog. See the following query for an example:

~~~js
Posts.find({}, {sort: {$natural: -1}, limit: 10});
~~~

Because it is using `$natural`, it won't be able to get the oplog support.

## Identify Above Scenarios

Now you clearly know why some of your observers cannot use oplog support. But it is really hard to find the reason for such queries in production, especially with invalid selectors.

From the very beginning, [Kadira](https://kadira.io) shows you whether oplog is enabled or not for your observers via its [tracing](http://support.kadira.io/knowledgebase/articles/347453-response-time-with-traces) support. But it doesn't tell you why. From today onward, you'll be to see the reason and the potential fix for your query.

![Oplog Debugging Support in Kadira](https://i.cloudup.com/FA2NrHshgj.png)

> You need to update your [kadira](https://atmospherejs.com/package/kadira) smart package to the latest version (2.4.3 or higher) in order to receive this feature.

Now you know how to optimize your app for Meteor’s oplog integration and find out whether oplog support is enabled for your individual observers. If it is not, Kadira will help you to determine the reason and fix it.

gha_language: CSS


text:
# enum-test-base

A simple base class for all your enum testing needs.

The default behaviour of the base class is to make sure that you have 100% test coverage on all of your standard enums.

More complex usage scenarios where you have additional behaviour and properties in your enums are also be supported,
including nested test classes.

## Usage

### Maven

```xml
<dependency>
  <groupId>eu.coldrye.junit</groupId>
  <artifactId>enum-test-base</artifactId>
  <version>1.0.0</version>
  <scope>test</scope>
</dependency>
```

### Examples

```java
package org.example;

import eu.coldrye.junit.bases.AbstractEnumTestBase;

public class SampleEnumTest extends AbstractEnumTestBase<SampleEnum> {

  // done, 100% coverage
}
```

## References

- [GitHub](https://github.com/coldrye-java/junit-testing/tree/master/enum-test-base)
- [Sonar](http://sonar.coldrye.eu/dashboard?id=eu.coldrye.junit%3Aenum-test-base)

repository: coldrye-testing/junit-testing

branch_name: refs/heads/dev

repo_name: coldrye-testing/junit-testing


text:
# NLP-Semantic Role Labeling (SRL)
Implementation of a Bi-GRU recurrent neural network in Pytorch for Semantic Role Labeling (SRL) in association with BERT. Project developed for Natural Language Processing course held by professor R. Navigli (Sapienza University of Rome).
Many other machine learning techinques are applied. For more information please check the pdf of the report.

## Notice
Unfortunately I am not allowed to share the dataset thereby you cannot download and run the code.

repository: pietro-nardelli/NLP-SRL

repo_name: pietro-nardelli/NLP-SRL


text:
# trap
Go module for graceful shutdown and signal handling

## Status
Currently in the testing phase. Do not use in production code without knowing what you are doing!

# Install
```bash
go get -u peterdekok.nl/gotools/trap
```

```golang
import "peterdekok.nl/gotools/trap"
```

repository: PeterDeKok/trap

repo_name: PeterDeKok/trap


text:
# Home Assistant configuration [![Build Status](https://travis-ci.org/bliemli/home-assistant-config.svg?branch=master)](https://travis-ci.org/bliemli/home-assistant-config)

My [Home Assistant](https://home-assistant.io) configuration files and screenshots.

## Table of contents

* [Controlled devices](#controlled-devices)
* [What's special?](#whats-special)
* [Screenshots](#screenshots)

## Controlled devices

* [Ubiquiti mPower power outlets](https://www.ubnt.com/mfi/mpower/)
* [Philips Hue lamps](http://www2.meethue.com/de-ch/productdetail/philips-hue-white-and-color-ambiance-starter-kit-a19)
* [Philips TV](http://www.mea.philips.com/c-p/47PFL6007H_12/6000-series-smart-led-tv-with-ambilight-spectra-2-and-pixel-precise-hd#see-all-benefits)
* [Linn Majik DSM media player](https://linn.co.uk/hifi-separates/network-music-players/majik)
* [Kodi media player](https://kodi.tv/)
* [OpenGarage cover](https://opengarage.io/)
* [iRobot Roomba 960](http://www.irobot.com/)

## What's special?

### Automation based on power consumption

The Ubiquiti mPower outlets can be used to read power consumption and to control socket states. This allows to automatically turn off power for devices that are in standby and which Home Assistant knows are not in use anymore. This is determined by the state of binary switches ('Music', 'TV' etc.).

Another possibility is to automatically switch the source of the amplifier to 'Phono' if the turntable is using energy.

### Switches based on input_select

Sometimes switches on the frontend are more appropriate, prettier or whatever than a dropdown list. The template switches defined in switches.yaml are based on an input_select component and make it possible to do a single selection switches group. So the same logic applies as for a dropdown list with one element active at all times, implemented as switches.

### Visibility of media players

Media players are quite large and take up a lot of space on the frontend. There's two groups containing media_player components, one group's always shown, the other only displays media players when they're active. This configuration is based on [danrspencer](https://github.com/danrspencer)'s work described on the [Home Assistant Forum](https://community.home-assistant.io/t/show-any-currently-active-media-player-on-default-view/23960?u=bliemli) and slightly modified to account for permanent media players.

## Screenshots

![Screenshot 1](images/ha01.png)
![Screenshot 2](images/ha02.png)

repository: bliemli/home-assistant-config

repo_name: bliemli/home-assistant-config


text:
# Cryptoexch

Data downloader from REST services.

I'm using this program in following data workflow:

- The program `cryptoexch` is deployed and run in cloud and collects data to cloud based storage
- Agent on my PC downloads those data when I turn on computer
- Then AI based program (which I constantly improve) analyze the data and when appropriate came up with signals pointing to particular markers to look at.

One of possible use cases for other users would be to clone program and clone `Zonda` module and modify for web service of choice (very easy task) or use module `GenericJson`. Main purpose of program is to constantly download new data and provide than in format more convenient for data analysis (like csv) or in more compact form (proto buffers) easier to manage.

## Features

- Downloads JSON data from configured Urls at given time intervals
- Can add flexible (e.g. time dependent) Url query parameters
- After given number of downloads saves collected data in the JSON file, whose name may contain auto-counter or date
- Can filter downloaded data
- Additional features for selected services:
  * [Zonda](https://Zonda.net) - additional output formats: csv, protocol buffers

## Cargo Features
Features which can be enabled / disabled during program build.

| Feature       | Default | Description |
|---------------|---------|-------------|
| `script_rhai` | off | Enables possibility to use [rhai](https://schungx.github.io/rhai/about/index.html) scripting language in configuration file |
| `out_csv`     | off | Enables CSV output file format |
| `out_pb`      | off | Enables Google Protocol Buffers output file format |
| `mod_zonda`   | off | Enables module to support [Zonda](https://zondaglobal.com) service  |
|               |     |   |

## Usage

Program invocation:
```
USAGE:
    cryptoexch [CONF]

FLAGS:
    -h, --help       Prints help information
    -V, --version    Prints version information

ARGS:
    <CONF>    Configuration file with tasks specification (default: program.yaml)
```

Sample configuration file (program.yaml):
```yaml
Config:
  LogConf: log4rs.yml

Tasks:
  - Module: Zonda
    Api: trading/candle/history
    PathParams: ETH-PLN/60
    QueryParams:
      from: |
        (now_utc_millis() - 900*1000).to_string()
      to: |
        now_utc_millis().to_string()
    Format: csv
    OutPathMask: samples/candle_ETH_PLN_%$.csv
    Frequency: 900
    StopAfter: 3
    NewFileAfter: 1
  - Module: GenericJson
    Url: "http://api.nbp.pl/api"
    Api: exchangerates/tables
    PathParams: A
    QueryParams:
      format: json
    Format: json_pretty
    OutPathMask: samples/exchangerates_%F.json
    StopAfter: 1
    Filters:
      - - rates
        - rhai
        - |
          val.code == "USD" ||
          val.code == "EUR" ||
          val.code == "CHF"
```
Program will make 3 queries with ETH-PLN rates in 15 minutes (900 seconds) intervals and save them in files: `candle_ETH_PLN_1.csv`, `candle_ETH_PLN_2.csv`, `candle_ETH_PLN_3.csv`. In parallel it will get today's rates for USD, EUR and CHF from Polish National Bank and save it in file: `exchangerates_2020-08-11.json`. Program exits when last task finish.

## Ideas / plans for further development

Program is in very initial state of development and is work in progress. Until 1.0.0 version is released some incompatible changes are possible including changes of format of main configuration file. Generally [semver](https://semver.org/) convention is used in program versioning.

Following are some ideas I consider to develop. Checked items are more likely to be added or ones for which development has started.

- [x] Implement `Config: PIDFile` option
- [ ] Process `PathParams` key in similar way as `QueryParams`
- [ ] Optimize parameters' processing - if there are no replacements, move parameter outside loop
- [ ] Data save procedures for some formats (pb) use blocking, sync functions
- [ ] Graceful shutdown
- [ ] To avoid races, files should be created / opened with .tmp extension and renamed to final name when completely done.
- [ ] Currently entire task exits when some invocation fails; make it more flexible - e.g. allow for next trials.
- [ ] Improve rhai scripts capabilities: e.g. introduce some container for state variables.
- [ ] Support for APIs that require authorization key.
- [ ] Support for [Kraken](kraken.com) crypto exchange.
- [ ] Special purpose module which allows user to run custom command (e.g. zip all created files).
- [ ] Support for more output formats - e.g. some compact binary formats compatible with Python pandas package, HDF5 or even direct injection to database.
- [ ] Integration tests

repository: gwierzchowski/cryptoexch

repo_name: gwierzchowski/cryptoexch


text:
# Rocket.Chat REST API for Ruby

This is a gem for [Rocket.Chat](https://rocket.chat/).

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'rocketchat', github: 'int2xx9/ruby-rocketchat'
```

And then execute:

    $ bundle

## List of supported API

Currently this gem supports below APIs only. (And also supports API version 0.1 only.)

* /api/version
* /api/login
* /api/logout
* /api/publicRooms
* /api/room/:id/join
* /api/room/:id/leave
* /api/room/:id/send

## Usage

To get Rocket.Chat version and API version:

```ruby
require 'rocketchat'

rcs = RocketChat::Server.new("http://your.server.address/")
version = rcs.version
puts "Rocket.Chat version: #{version.rocketchat}"
puts "API version: #{version.api}"
```

To find public rooms:

```ruby
require 'rocketchat'

rcs = RocketChat::Server.new("http://your.server.address/")
rc = rcs.login("username", "password")
rc.public_rooms.each do |room|
  puts "##{room.name}(#{room.id}): #{room.msgs}messages"
end
```

You can also use [] to open a specific room.

```ruby
require 'rocketchat'

rcs = RocketChat::Server.new("http://your.server.address/")
rc = rcs.login("username", "password")
puts "#general has #{rc["general"].msgs} messages"
```

To join or leave a room:

```ruby
require 'rocketchat'

rcs = RocketChat::Server.new("http://your.server.address/")
rc = rcs.login("username", "password")
rc["dev"].join
rc["dev"].leave
```

To send a message:

```ruby
require 'rocketchat'

rcs = RocketChat::Server.new("http://your.server.address/")
rc = rcs.login("username", "password")
rc["dev"].post("message")
```

To logout from a server.

```ruby
require 'rocketchat'

rcs = RocketChat::Server.new("http://your.server.address/")
rc = rcs.login("username", "password")
# ... join, leave, send a message, etc ...
rc.logout
```

## Contributing

Bug reports and pull requests are welcome on GitHub at https://github.com/int2xx9/ruby-rocketchat.

## License

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


text:
---
title: "Binary to Decimal Conversion"
video_number: 119
date: 2018-10-23
video_id: meGcdIoTYgw
web_editor: HJn1hOPjX
repository: CC_119_Binary_to_Decimal_Conversion

links:
  - title: "Code"
    url: "https://editor.p5js.org/codingtrain/sketches/HJn1hOPjX"
  - title: "Ternary Operator"
    url: "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_Operator"

videos:
  - title: "Seven-Segment Display"
    url: "/CodingChallenges/117-seven-segment"

contributions:
  - title: "ASCII to Binary Conversion"
    author:
      name: "Knut Jackowski"
      url: "http://doxanthropos.com"
    url: "https://doxanthropos.github.io/sketchbook/2018102301/"
    source: "https://github.com/doxanthropos/sketchbook/tree/master/2018102301"
  - title: "Binary Game"
    author:
      name: "Shivanshu Kant Prasad"
    url: "https://shivanshukantprasad.github.io/BinaryGame/"
    source: "https://github.com/ShivanshuKantPrasad/BinaryGame"
  - title: "Binary to Decimal Particles"
    author:
      name: "Gonzalo Pierola Azanza"
    url: "https://editor.p5js.org/Guamedo/full/SklfTMn2s7"
    source: "https://github.com/Guamedo/P5/tree/master/Bin2Dec"
  - title: "Binary Rainbow"
    author:
      name: "Tim Mallard"
    url: "https://editor.p5js.org/Mallard/full/ryF3vf0sQ"
    source: "https://editor.p5js.org/Mallard/sketches/ryF3vf0sQ"
---

In this coding challenge, I discuss binary numbers and make an interactive binary to decimal number converter.


text:
# ctakes-rest-service

## Description

_(NOTE: This is alpha software... this project is under active development!)_

The goal of this solution is to provide a JSON-based REST service to process unstructured clinical text through a smart natural language processing system in a fast, accurate, and easy to setup way.

This software provided to the open source healthcare community by:

- Gandhirajan N (Technical Architect)
- Sandeep B G (Solutions Architect)
- Matthew V (Software Engineer)

Thanks to the following people for support and guidance:

- Timothy M, PhD (Scientific Researcher)
- Sean F (Senior Software Developer)

## Setup

Install [Docker](https://www.docker.com/) for your platform (Windows/Linux/Mac)..

```
docker-compose up
```

## Endpoint

HTTP POST `data` to `http://localhost:8080/ctakes-nlp-service/ctakesnlp/analyze`

## Custom Dictionaries

To use a custom dictionary, adjust `customDictionary.xml` to meet your needs and replace (instructions here) file in `Dockerfile` to have the build convert the contents to MySQL tables.

## Remaining Version 1 Work

1. Setup docker-compose with multiple containers
2. Write CtakesHsqlToMysql.java
3. Use our current solutions to finalize CtakesConceptMentionParser.java
4. Make CtakesHsqlToMysql.java parallel
5. Custom dictionary testing
6. Support UMLS credentials
7. Fix unit tests
8. Setup basic auth Spring Security
9. Test with https://github.com/GoTeamEpsilon/cTAKES-Friendly-Web-UI
10. Work with Sean and Tim to do SVN merge
11. Write press release
12. test with ctakes-friendly-web-vierwer
13. cTAKES Friendly Web UI

## License

Apache License, Version 2.0

repository: MatthewVita/cTAKES

repo_name: MatthewVita/cTAKES