text:
# surveyd-app

A large feedback-collection app.

## Overview

This application lets you send surveys via email to thousands of recipients at one time. You to customise the content of the email, and track each response to the surveys via the dashboard. This pay-as-you-go service where one credit can send out one batch of surveys.

## Quick Start

To get started locally, you will need to perform the following steps in both the `backend` as well as the `frontend` of the application:

**Backend:**

```
npm install
npm run dev # NOTE: This will run both `client` & `server`
# open localhost:3000 in web browser to access the client
```

**Frontend:**

To specifically run the client server only:

```
npm install
npm run start
# open localhost:3000 in web browser
```

**To setup Ngrok for webhook development/testing:**

```
# open a new terminal tab/window
npx ngrok http 5000
# cp ngrok address into SendGrid configuration dashboard:
# Dashboard>Settings>Mail Settings>Event Webhook
# ex: http://3b015e41cb2a.ngrok.io/api/surveys/webhooks
```

## Deployments

The Production endpoint environment for this application is hosted in Heroku. To deploy, simply use this command:

`$ git push heroku master`

## Environments

Various keys and configuration changes must be made on both Heroku and SendGrid to properly use and test this application. By default, the config is wired up and pointed to Production assets.

**Dev/QA:** `localhost`

**Prod:** `https://secure-forest-73972.herokuapp.com/`

Each target endpoint has thier own unique sets of keys - be sure to update the necessary keys in SendGrid to properly develop and test via `localhost`.

## Technologies & Frameworks

- [Axios](https://github.com/axios/axios)
- [Babel](https://babeljs.io/)
- [Create React App](https://facebook.github.io/create-react-app/)
- [Docker](https://www.docker.com/)
- [Express](https://expressjs.com/)
- [Heroku](https://www.heroku.com/)
- [Kubernetes](https://kubernetes.io/)
- [Materialize](https://materializecss.com/)
- [MongoDB](https://www.mongodb.com/)
- [Mongoose](https://mongoosejs.com/)
- [Ngrok](https://ngrok.com/)
- [Node](https://nodejs.org/)
- [OAuth](https://oauth.net/2/)
- [Passport](http://www.passportjs.org/)
- [React Stripe Component](https://github.com/stripe/react-stripe-js)
- [React](https://reactjs.org/)
- [Redux-Form](https://redux-form.com/)
- [Redux](https://redux.js.org/)
- [SendGrid](https://sendgrid.com/)
- [Stripe](https://stripe.com/)
- [Travis CI](https://travis-ci.org/)
- [Webpack](https://webpack.js.org/)

repository: adamdubey/surveyd-app

repo_name: adamdubey/surveyd-app


text:
Cwrap: Wraps C libraries in Go
==============================

Cwrap is a Go wrapper generator for C libraries.

Features
--------
* No Cgo types exposed out of the wrapper package, and uses as less allocation/copy as possible.
* C name prefix mapped to Go packages, and a wrapper package can import another wrapper package.
* Follows Go naming conventions.
* C union.
* Use Go language features when possible:
  * string and bool.
  * Multiple return values.
  * Slice, slice of slice and slice of string.
  * struct with methods.
  * Go closures as callbacks.
* Stay out of the way when you need to do it manually for specified definitions.

Examples
--------
In the examples directory, there are C libraries that I have successfully applied Cwrap, including:
* GSL (GNU Scientific Library)
* PLplot
* SDL2 (Simple DirectMedia Layer)

You are very welcome to submit examples you think useful to others.

Issue Report
------------
Cwrap may not cover every possible case and fails to come up with a corrresonding Go type or convertion, then the generated code may not be able to compile. When this happens, do the following steps:

1. Comment out the failed function wrappers till it compiles.
2. Add the C names of these failed functions to the excluded list (Package.From.Excluded).
3. Submit the generator example to me. I cannot guarantee anything but I will try to fix critical issues.

TODO
----
* Alignment and padding of generated Go struct fields may need more careful checking (currently no checking is done at all, Cwrap just naively assume the same rules are applied to both Go and C).

Limitations
-----------
* C variadic functions (...) are not supported.

Acknowledgement
---------------
Cwrap uses gccxml (http://gccxml.github.io) to parse C headers to an XML file. Thanks very much for their excellent work.

repository: sbinet/cwrap

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: sbinet/cwrap


text:
# streamlit-aggrid

This is just a proof of concept. Links below:

* [Open in Streamlit Share](https://share.streamlit.io/pablocfonseca/streamlit-aggrid/main/example.py])

* [GitHub](https://github.com/PablocFonseca/streamlit-aggrid])

* [pypi.org](https://test.pypi.org/project/streamlit-aggrid/)

This just a proof of concept.

AgGrid is an awsome grid for web frontend. More information in [https://www.ag-grid.com/](https://www.ag-grid.com/)

Comment on [discuss.streamlit.io](https://discuss.streamlit.io/t/ag-grid-component-with-input-support/) if you like this!

Pablo Fonseca

# Install
```
pip install -i https://test.pypi.org/simple/ streamlit-aggrid

```

# Quick Use
Create an example.py file
```python
from st_aggrid import AgGrid

df = pd.read_csv('https://raw.githubusercontent.com/fivethirtyeight/data/master/airline-safety/airline-safety.csv')
AgGrid(df)
```
Run :
```shell
streamlit run example.py
```

# Demo
Grid data is sent back to streamlit and can be reused in other components. In the example below a chart is updated on grid edition.

![example image](https://github.com/PablocFonseca/streamlit-aggrid/raw/main/example.gif)

# Row Selection Demo
Selected grid data is stored in ['data'] key on returned dict from AgGrid call

![selection example](https://github.com/PablocFonseca/streamlit-aggrid/raw/main/selection_example.gif)

license: MIT

repository: andfanilo/streamlit-aggrid

branch_name: refs/heads/main

gha_license_id: MIT

repo_name: andfanilo/streamlit-aggrid


text:
# shotgun-metagenomics

## Summary

This pipeline analyses paired-end shotgun metagenomics data. In a
first step is trims adapters and low-quality bases by using
Skewer. Reads are then decontaminated against reference specified in
the config file (default: human). Then, several metagenomics profilers
(default: Kraken and Metaphlan2) and a pathway analysis with HUMAnN2
is performed. Results aggregated over all input samples.

This pipeline was originally developed by
[Chenhao Li](https://github.com/orgs/CSB5/people/lch14forever) (see
[Github repository](https://github.com/CSB5/shotgun-metagenomics-pipeline)).

## Output

The following list the main output files

- `merged_table_{profiler}/{tax}.{profiler}.profile_merged.tsv` where
  `profiler` can be `kraken` or `metaphlan2` and `tax` is a one-letter
  abbreviation for taxonomic rank (e.g. `g` for genus).
- `merged_table_humann2/genefamily.tsv`: Abundance (in RPK) of each
  gene family (each row) in each sample (each column)
- `merged_table_humann2/pathabundance.tsv`: Abundance of each pathway
  in each sample. The pathways are stratified into species.
- `merged_table_humann2/pathcoverage.tsv`: Presence (1)/absence (0)
  code for each pathway in each sample.

## References

- Skewer: [Publication](https://www.ncbi.nlm.nih.gov/pubmed/24925680) and [website](https://github.com/relipmoc/skewer)
- Kraken: [Publication](https://genomebiology.biomedcentral.com/articles/10.1186/gb-2014-15-3-r46) and [website](https://ccb.jhu.edu/software/kraken/)
- Metaphlan2: [Publication](https://www.nature.com/nmeth/journal/v12/n10/full/nmeth.3589.html) and [website](http://segatalab.cibio.unitn.it/tools/metaphlan2/)
- HUMAnN2: [Website](http://huttenhower.sph.harvard.edu/humann2)
- Decont: [Website](https://github.com/CSB5/decont)

repository: kohjy-ag/pipelines

repo_name: kohjy-ag/pipelines


text:
### [CVE-2020-2230](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-2230)
![](https://img.shields.io/static/v1?label=Product&message=Jenkins&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=%3C%3D%202.251%20&color=brighgreen)
![](https://img.shields.io/static/v1?label=Vulnerability&message=CWE-79%3A%20Improper%20Neutralization%20of%20Input%20During%20Web%20Page%20Generation%20('Cross-site%20Scripting')&color=brighgreen)

### Description

Jenkins 2.251 and earlier, LTS 2.235.3 and earlier does not escape the project naming strategy description, resulting in a stored cross-site scripting (XSS) vulnerability exploitable by users with Overall/Manage permission.

### POC

#### Reference
- http://packetstormsecurity.com/files/160443/Jenkins-2.235.3-Cross-Site-Scripting.html

#### Github
- https://github.com/Live-Hack-CVE/CVE-2020-2230

repository: trickest/cve

gha_language: HTML

repo_name: trickest/cve


text:
PouchDB Full Sync
=====

[![Build Status](https://travis-ci.org/nolanlawson/pouchdb-full-sync.svg)](https://travis-ci.org/nolanlawson/pouchdb-full-sync)

Fully replicate two PouchDB or CouchDB databases, while preserving absolutely all document history and conflicts.

Useful for:

* Implementing infinite undo/redo in your app
* Building a Git-like VCS on top of CouchDB/PouchDB
* Building a collaborative wiki, where all edits ever are preserved

Description
----

Normally, the CouchDB replication protocol only replicates the **leafs** between two databases. This preserves conflicts (which is awesome!), but it discards **non-leafs** for performance reasons.

You can visualize it like this. Here's what CouchDB/PouchDB normally does:

The non-leaf revisions `1-x`, `2-x`, and `3-x` are lost during replication, but the conflicting leafs `3-y` and `4-x` are kept. If you try to fetch the non-leafs from the target database (e.g. using `db.get('id', {rev: '1-x'})`), then you'll see `{"error": "not_found", "reason": "missing"}`.

Incidentally, this is the same thing that happens during [compaction](http://pouchdb.com/api.html#compaction).

Now, here's what PouchDB Full Sync does:

Notice that all the revisions are kept, even the non-leafs. So you can call `db.get('id', {rev: '1-x'})` and the data will be there!

Usage
----

### In the browser

To use this plugin in the browser, include it after `pouchdb.js` in your HTML page:

```html
<script src="pouchdb.js"></script>
<script src="pouchdb.full-sync.js"></script>
```

It's also available from Bower:

    bower install pouchdb-full-sync

### In Node.js/Browserify

Or to use it in Node.js, just npm install it:

```
npm install pouchdb-full-sync
```

And then attach it to the `PouchDB` object:

```js
var PouchDB = require('pouchdb');
PouchDB.plugin(require('pouchdb-full-sync'));
```

API
---

There are three new methods, which have exactly the same APIs as the old methods:

* `db.fullyReplicateTo()` emulates `db.replicate.to()`
* `db.fullyReplicateFrom()` emulates `db.replicate.from()`
* `db.fullySync()` emulates `db.sync()`

So you will want to refer to the original documentation for [`replicate()`](http://pouchdb.com/api.html#replication) and [`sync()`](pouchdb.com/api.html#sync) to understand how to use this plugin.

Examples:

```js
var db = new PouchDB('mydb');
var remoteDB = new PouchDB('http://localhost:5984/mydb');

// fully replicate to another database
db.fullyReplicateTo(remoteDB);

// fully replicate from another database
db.fullyReplicateFrom(remoteDB);

// fully sync two databases
db.fullySync(remoteDB);
```

The same promise/callback/event APIs are supported. So for instance, you can do a one-shot replication with promises:

```js
db.fullySync(remoteDB).then(function () {
  // all done!
}).catch(function (err) {
  // got an error!
});
```

Or you can use the familiar event listeners:

```js
db.fullySync(remoteDB, {
  live: true,
  retry: true
}).on('change', function (info) {
  // handle change
}).on('paused', function () {
  // replication paused (e.g. user went offline)
}).on('active', function () {
  // replicate resumed (e.g. user went back online)
}).on('denied', function (info) {
  // a document failed to replicate, e.g. due to permissions
}).on('complete', function (info) {
  // handle complete
}).on('error', function (err) {
  // handle error
});
```

Caveats
---

If you want to permanently preserve history, you should never call `compact()` or enable `auto_compaction`. Once you compact, the non-leaf revisions in that database are lost.

Also, your database can grow wildly out of control, because CouchDB/PouchDB is storing your full document history. Be cognizant of [browser data limits](http://pouchdb.com/faq.html#data_limits).

Also, be forewarned that CouchDB 2.0 will deprecate the `_compact` API, meaning that it will compact whenever it deems necessary. So at that point, you may need to stick with CouchDB 1.x or PouchDB Server.

This plugin also supports replicating between two CouchDBs (since PouchDB itself can do that), but note that the changes will flow through PouchDB, rather than using the CouchDB replicator at the `/_replicate` endpoint.

PouchDB currently has a hard limit of 1,000 revisions ([unless you help fix it :smile:](https://github.com/pouchdb/pouchdb/issues/2839)), at which point it will cut off the revision history. CouchDB has a [`_revs_limit` API](https://wiki.apache.org/couchdb/HTTP_database_API#Accessing_Database-specific_options) which you can use to configure the limit.

This algorithm is also less efficient than PouchDB's original replication algorithm, because it involves more `GET` requests to fetch the parent revisions. When the [bulk revs API](https://issues.apache.org/jira/browse/COUCHDB-2310) is finished, it can be improved.

Building
----

    npm install
    npm run build

Testing
----

### In Node

This will run the tests in Node using LevelDB:

    npm test

You can also check for 100% code coverage using:

    npm run coverage

If you don't like the coverage results, change the values from 100 to something else in `package.json`, or add `/*istanbul ignore */` comments.

### In the browser

Run `npm run dev` and then point your favorite browser to [http://<IP_ADDRESS>:8001/test/index.html](http://<IP_ADDRESS>:8001/test/index.html).

The query param `?grep=mysearch` will search for tests matching `mysearch`.

### Automated browser tests

You can run e.g.

    CLIENT=selenium:firefox npm test
    CLIENT=selenium:phantomjs npm test

This will run the tests automatically and the process will exit with a 0 or a 1 when it's done. Firefox uses IndexedDB, and PhantomJS uses WebSQL.

repository: pouchdb-community/pouchdb-full-sync

repo_name: pouchdb-community/pouchdb-full-sync


text:
---
layout: post
status: publish
published: true
title: Austin PHP Frameworks Series - Symfony 2
author:
  display_name: llbbl
  login: admin
  email<EMAIL_ADDRESS>  url: ''
author_login: admin
author_email<EMAIL_ADDRESS>excerpt: ! "http://www.youtube.com/watch?v=aGHtakwTzP8\r\n"
wordpress_id: 120
wordpress_url: http://austintechvideos.com/?p=120
date: !binary |-
  MjAxMS0xMi0xOSAwNjozMTowOSAtMDYwMA==
date_gmt: !binary |-
  MjAxMS0xMi0xOSAwNjozMTowOSAtMDYwMA==
categories:
- AustinTechVideos
- AustinPHP
tags:
- austinphp
- php
comments: []
videoid: aGHtakwTzP8
description: Will be covering Symfony 2 this month.
---

Don't know what the CRUD Project is? The CRUD project is a basic web application implemented in many different PHP Frameworks. We are planning on using the 5.3 frameworks where possible.

Interested in following along while we build the CRUD apps? We are putting it all out on our github.

https://github.com/austinphp/frameworks

08.09.2011

extension: markdown

gha_language: JavaScript


text:
Role Name
=========

This role could be used while bootstrapping nodes on cloud or on your VM to echo/display the hostname along with any relevant details like privacy policy etc.

Requirements
------------

Role Variables
--------------

None

Dependencies
------------

None

Example Playbook
----------------
You could pass a parameter to the role like below:

roles:
  - {role: ssh-banner, host: 'My Machine' ,tags: ['ssh-banner', 'banner', 'bootstrap', 'provision']}

License
-------

BSD

Author Information
------------------

Contact me on<EMAIL_ADDRESS>for help/issue/queries regarding this role.

repository: Miyurz/ansible-role-ssh-banner

repo_name: Miyurz/ansible-role-ssh-banner


text:
# vigilant-potato

This script is a graphic solution to determine the critical condition in the saltwater upconing in a leaky confined aquifer based on analytical solution derived from Bower, et al (1999).  The critical rise and critical pumping rate of saltwater upconing are solved when equal pressure and equal pressure gradient conditions both exist.  Above the critical condition, the exerted pumping will induce an unstable freshwater-saltwater cone.

Two functions were solved using SciPy package-Modified Bessel function of the second kind of integer order zero.  Script was set up to solve for parameters sets posed by Figure 4 (Bower, et al., 1999) for comparison and validation.  Script was also set up to solve for user input parameters defined in the “Parameters.txt”:

#Distance from the top of the aquifer to the bottom of the well screen (m)

#Thickness of the aquifer from the bottom of the confining unit to the initial condition of the saltwater-freshwater interface (m)

#Distance from the top of the aquifer to the top of the screen (m)

#Radial distance from the pumping well (rw) (m)

#Vertical hydraulic conductivity of the aquifer (m/day)

#Horizontal hydraulic conductivity of the aquifer (m/day)

#Vertical hydraulic conductivity of the overlying confining unit (m/day)

#Thickness of the overlying confining unit (m)

#Transmissivity of the aquifer (m2/day)

#Summation factor (Define the accuracy of the solution, with a greater summation factor, accuracy improves and runtime increases) (dimensionless)

A graphical representation of the parameters can be found in Figure 3 (Bower, et al., 1999).  I would love to hear any feedback and comments.

Reference:
#Bower, J. W., Motz, L. H., and Durden, D. W. (1999). Analytical solution for determining the critical condition of saltwater upconing in a leaky artesian aquifer. Journal of Hydrology, 221(1-2), 43-54.

license: Unlicense

repository: hangjiankiwi/vigilant-potato

repo_name: hangjiankiwi/vigilant-potato


text:
---
layout: default
---

# 1997-08-23 - Re: Plot of the Platypus

## Header Data

From: John Young<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 4171c909a5a321f75b78d125fde4fec17d69013690ed0930e826e9a29e42ae9f

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1997-08-23 16:47:32 UTC

Raw Date: Sun, 24 Aug 1997 00:47:32 +0800

## Raw message

```
{% raw  %}From: John Young<EMAIL_ADDRESS>Date: Sun, 24 Aug 1997 00:47:32 +0800
To<EMAIL_ADDRESS>Subject: Re: Plot of the Platypus
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

THE LIE wrote:
>
>In fact, many disorders of reading (alexia) and writing (agraphia)
>exist, and are sourced to small lesions in different areas of the brain.

Moreover, upon finer resolution of examination or by use of a different tool,
disorders are often discovered to be indistinguishable from orders with
a slightly larger maw.

Thus, do maws and survivalist manuals and bibles and cults of
incontrovertible wisdom thrive and beef-up and kudzu every
more uncontrollability, until ... the four bad-ass dudes ride in to waste the
evanescent land and mindscape, allowing the cosmo-launder cycle to
rejigger.

We've a stack of pre-owned omni-space-time prayerbooks for offer,
e-ver or tear-and-blood-stained print.

{% endraw %}
```

## Thread

+ Return to [August 1997](/archive/1997/08)

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

+ 1997-08-23 (Sun, 24 Aug 1997 00:47:32 +0800) - Re: Plot of the Platypus - _John Young<EMAIL_ADDRESS>


text:
# Part 4: using `rcall` for writing Stata packages

# Stata programming with `rcall`

- `rcall` allows embedding R code inside Stata programs
- It also provides a strict procedures for executing the computation
    - checking for required dependencies (R version, versions of R packages)
	- making sure the analysis is reproducible, by starting a new R environment
	- providing tools for checking required Stata dependencies and `rcall` version
- Programming with `rcall` is best practiced if Stata syntax is adopted

# Example Stata programs utilizing `rcall`

- examples in the manuscript: [Seamless interactive language interfacing between R and Stata](https://journals.sagepub.com/doi/10.1177/1536867X19830891)
- example packages written by the community
	- type __`github search rcall, all in(all)`__

# `github search rcall, all in(all)`

![Stata packages based on `rcall` ](./images/githubsearchrcall.png)

# Example 1: Loading data from CSV file

![example program for loading CSV files in Stata](./images/rdata.png)

~~~
//import delimited "credit.csv",  clear
rdata using "credit.csv", stringsasfactor
~~~

# Is R installed? What R version is needed?

![example program for loading CSV files in Stata](./images/rdata2.png)

# What if error occurs?

![example program for loading CSV files in Stata](./images/rdata3.png)

# Package versions & returning objects to Stata?

- you can specify a particular package version or a minimum version for dependencies
- check the version of the dependencies using `packageVersion("pkgname")` function

~~~
. R: packageVersion("C50")
[1] ‘0.1.5’
~~~

- The `rcall_check` command can examine the required package dependencies as well
- `rcall` automatically returns objects from R to Stata function
    - include the `return add` command to pass the objects to the mother enviornment

- - -

![example package with strict package version](./images/c5.png)
![returning the results to Stata](./images/c5_results.png)

# Programmers can get benefit of both Stata and R syntax

- Tips
    - Implement Stata syntax in your program carefully
	- Consider writing an R functions as well
	- simplifies passing arguments between Stata and R
![Example program to summarize variables with Stata syntax](./images/summaryprogram.png)

- - -

![Example program to summarize variables with Stata syntax](./images/summaryprogram2.png)

# Example of programming with R graphical packages

![A Stata program that utilizes ggplot2 package](./images/qplot.png)

- - -

~~~
. rplot price mpg , filename(graph) colour(foreign) shape(foreign) format(png)
~~~

![Example output generated by ggplot2](./images/graph.png)


text:
Watchable Object
====

Requirements
----

- when you create a new object and pass in a state, it must pass by copy not reference
- only single-level keys are supported

### Patches

- whenever a change is made to the object's state, a patch object is created
- patch object signature: `{ rev: string, data: [ type(string), key(string), args:mixed ] }`

- NOTE: `patch.rev` is the head revision of the entire object, at the point in time just prior to applying the patch (not the head revision of the object _after_ applying the patch).

repository: joshwnj/watchob

repo_name: joshwnj/watchob


text:
# NowShowing v2

![](https://raw.githubusercontent.com/ninthwalker/NowShowing/v2/images/ns_v2_title.png)

[![Docker Automated build](https://img.shields.io/docker/automated/ninthwalker/nowshowing.svg)](https://hub.docker.com/r/ninthwalker/nowshowing/) ![](https://img.shields.io/docker/pulls/ninthwalker/nowshowing.svg) [![](https://images.microbadger.com/badges/image/ninthwalker/nowshowing:v2.svg)](https://microbadger.com/images/ninthwalker/nowshowing:v2 "NowShowing") [![Build Passing](https://img.shields.io/badge/build-passing-brightgreen.svg)](https://hub.docker.com/r/ninthwalker/nowshowing/)

## Introduction
The NowShowing docker provides a summary of new media that has recently been added to Plex, giving the Plex owner the option of delivering the information in two ways:
1) An email summary sent to all or selected users of the Plex Server
2) A web page for users to visit

## Description / Background
NowShowing is the successor of the popular plexReport docker. The original brainchild of [bstascavage](https://github.com/bstascavage/plexReport). Further developed by NinthWalker & enhanced by GroxyPod, NowShowing adds additional improvements and features in a friendly, easy to install docker.

## New in v2:
### Complete code rewrite with tons of new features!
* Same great Email/webpage for Plex recently added as v1
* All new Web Interface for settings and customization
* Library Filtering!
* Movie/TV Trailers
* [Tautilli](https://github.com/Tautulli/Tautulli) Statistics integration
* New user Setup Wizard
* Announcement Emails
* Web based Log Viewer
* Easy Plex token retrieval
* Most email providers supported
* BCC users instead of multiple emails
* Web tools including On-Demand and Test reports

### [Screenshots](https://github.com/ninthwalker/NowShowing/wiki/Screenshots)

## Supported Platforms
* Docker (Windows or Linux based) [See Wiki](https://github.com/ninthwalker/NowShowing/wiki/Other-Docker-Platforms)
* unRAID v6+

## Supported Email Clients
* Most Email providers with SSL SMTP support [see Wiki FAQ](https://github.com/ninthwalker/NowShowing/wiki/FAQ-&-Known-Issues)

## Supported Plex Agents
* Plex Movie
* TheMovieDB
* TheTVDB

## Prerequisites
1.  Plex
2.  Docker
3.  Plex Movie or TheMovieDB set as your Agent for Movie sections on the Plex server
4.  TheTVDB set as your Agent for TV sections on the Plex server
5.  An Email account that supports SSL SMTP

## Installation on unRAID
[See unRAID Wiki](https://github.com/ninthwalker/NowShowing/wiki/unRAID-Instructions)

## Installation on other Docker platforms
[See Other Docker platforms Wiki](https://github.com/ninthwalker/NowShowing/wiki/Other-Docker-Platforms)

## Advanced settings, FAQ, Command-line options & other questions:
[See Github Wiki](https://github.com/ninthwalker/NowShowing/wiki)

repository: ninthwalker/NowShowing

gha_language: Ruby

repo_name: ninthwalker/NowShowing


text:
ManagePosts
===========

This library is to associate a SermonBrowser sermon with an mp3 file that has been already loaded to that website.

Prerequisites
=============
For this script to work, firefox and the geckodriver needs to already have been installed on your system.  The geckodriver software can be found here:

https://github.com/mozilla/geckodriver/releases

Please insure the geckodriver executable is in you PATH.

Examples
========

Example scripts can be found under the *examples* directory

repository: cpcissaquah/ManagePosts

repo_name: cpcissaquah/ManagePosts


text:
# SA based FPGA placer
The implementation of a simulated annealing based standard-cell placement tool.

### Objective
![floorplan](https://user-images.githubusercontent.com/15523357/28557837-9f456f8e-70c3-11e7-8dcc-da1d90a1557b.png)

Each space which can be occupied by a cell is referred as a cell site. There are nx sites and ny rows. The problem is to design a tool to place each cell of a circuit on the floor-plan while following any given design rules, which are discussed in the next section.

### Design Rules
* All the cells in a circuit are squares and have the same size(same height and width).
* We cannot assign more than one cell to each site/space on the floor-plan.
* The routing channel is of the same height as a row of cells.
* The distance between two cells is measured from the center of one cell to the center of the other.
* No extra artificial penalties are given for a net which crosses a row.
* The product of nx* ny should be at least as large as the number of cells in the circuit.

### Requirements
In order to run the program, the user is required to have the following modules installed:
* Python 3.x
* Matplotlib
* Numpy

### Pseudocode
The basic pseudocode for the placement tool is given below:
```
1: select circuit
2: set initial placement
3: set initial temperature and iterations
4: While not exit condition do
5:    For k iterations do
6:        select cells to swap
7.            Calculate new cost
8.            Calculate deltaC = New cost - Old cost
9.        if(deltaC <0)
10.           Accept the solution
11.       Else:
12.           R = rand(0,1)
13.           if(R< e−deltaC/T )then
14.               Accept the solution
16.           Else
17.               Reject solution
18.       End if
19.   End for
20.   Update T
21.   Update net criticality
22.End while
```
### License

MIT License

Copyright (c) 2018 Jaspreet Jhoja

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

 IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

gha_language: Python


text:
![logo](https://raw.githubusercontent.com/Horizon0156/Horizon.MvvmFramework/master/Icon.png)

# Horizon.MvvmFramework
The MvvmFramework is a simple and lightweight framework supposed to speed-up the development of MVVM (Model-View-ViewModel) applications as well as to reduce code of common operations such as change notifications.

The main component is build as a portable class library so it can be used "view" independently. The Wpf submodule of this framework contains WPF specific behaviors and extensions. This framework was extracted from a working productive application. It will be extendend if a code snippet is worth to be added and might be helpful for common use cases. This project is a private project written during leasure time, published in hopes that it will be useful for other projects too. Last but not least, feel free to extend the framework :)

## Installation
Simply use this framework by referencing one of the following NuGet packages.

* <https://www.nuget.org/packages/Horizon.MvvmFramework/>
* <https://www.nuget.org/packages/Horizon.MvvmFramework.Wpf/>

## Documentation
Head over to <https://horizon0156.github.io/Horizon.MvvmFramework/> which provides information of the framework's components and how to make use of them.


text:
---
layout: default
---

# 1997-11-03 - re: Speech as co-conspiring? I don't think so.

## Header Data

From: Secret Squirrel<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: a71115f5c6da08eaf328b7cc08c3816eeac83ef228226b1bf2372c24e29427df

Message ID: \<439400e9f3604a48781f48485a000403@squirrel\>

Reply To: _N/A_

UTC Datetime: 1997-11-03 00:27:32 UTC

Raw Date: Mon, 3 Nov 1997 08:27:32 +0800

## Raw message

```
{% raw  %}From: Secret Squirrel<EMAIL_ADDRESS>Date: Mon, 3 Nov 1997 08:27:32 +0800
To<EMAIL_ADDRESS>Subject: re: Speech as co-conspiring? I don't think so.
Message-ID: <439400e9f3604a48781f48485a000403@squirrel>
MIME-Version: 1.0
Content-Type: text/plain

-----BEGIN PGP SIGNED MESSAGE-----

Monty Cantspell, Editor in Chief of Groan Magazine, wrote:
>> There was a discussion a little while ago suggesting that toad.com had
>> been compromised by people who were sowing dissension by partially
>> distributing certain messages.  Had toad signed all of its messages,
>> it would be possible to obtain evidence supporting this hypothesis
>> without relying entirely on the word of people we may not know.
>
>How do signed messages deal with the incompleat distribushun problem?
>If legit signed messages are not sent to half the list, what does the
>sig gain us?

When Attila says "I have this message from the list" and it has a
valid signature, it makes things considerably more interesting because
we don't have to trust Attila very much.  For instance, it may give
the owner of the signing key incontrovertible proof that his machine
was compromised.  If we have several examples of messages which are
slightly different from each other and are signed by the list key, we
know that an attack was mounted, although we may not know by whom.

>> Had somebody compromised toad, they would still have to correctly sign
>> messages.
>
>But, depending on the compromise, this could be possible.

I phrased that badly.  What I meant to say was that the person who
compromised the machine may be able to sign messages, but he or she
will still have to sign all the messages going out.  Which means that
they can be compared later, which may show incontrovertible proof that
Something Is Wrong And It Is Wrong In A Most Interesting Way.

Monty Cantsin
Editor in Chief
Smile Magazine
http://www.neoism.org/squares/smile_index.html
http://www.neoism.org/squares/cantsin_10.htm

-----BEGIN PGP SIGNATURE-----
Version: 2.6.2

iQEVAwUBNFzqp5aWtjSmRH/5AQFAsgf7B2F4xDdQZc4koltSO1exTkAGIzxH8nCP
7lh5r2P3vPhC1BfxkCMr3+kTIAuTcXPhvkmGxXNGjud+wqPOW/BYDPUfyjGDQ/rD
TZOM23iqVYZIfiiyEdl3DbqmiIv7W0Zrs8b9yhlDnjWPXGnqmgu5QV8LM3QHEEKk
nOhKz+qm3cv4UNI9wK87+PjmFKNN9JZCq3WsFCYPI9QSCJR9qgZ7YXnGAPGs7dbG
CYRhRYRUMPYBha2RfROvkU5xWH32iRE0bdLQ/uxCjL0vZxoMSq5gDMAjm1Hu02+L
8qTsyCK/LeCRBwtNBCHTO70E71lsV2jD+03Xcxm3SzYHnNo5G6RUHQ==
=x/pi
-----END PGP SIGNATURE-----

{% endraw %}
```

## Thread

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

+ Return to "[Secret Squirrel <nobody@secret.squirrel.owl.de>](/authors/secret_squirrel_nobody_at_secret_squirrel_owl_de_)"
+ Return to "[TruthMonger <tm@dev.null>](/authors/truthmonger_tm_at_dev_null_)"

+ 1997-11-03 (Mon, 3 Nov 1997 08:27:32 +0800) - re: Speech as co-conspiring? I don't think so. - _Secret Squirrel<EMAIL_ADDRESS>  + 1997-11-03 (Mon, 3 Nov 1997 08:52:17 +0800) - [Re: Speech as co-conspiring? I don't think so.](/archive/1997/11/54d5e126097cb3141fba2a3d9c949a91423fc7f7ca1e43de76aee61f8009253e) - _TruthMonger<EMAIL_ADDRESS>


text:
# Laccaria laccata var. laccata (Scop.) Cooke VARIETY

#### Status
ACCEPTED

#### According to
Index Fungorum

#### Published in
Grevillea 12(no. 63): 70 (1884)

#### Original name
Laccaria laccata var. laccata (Scop.) Cooke

### Remarks
null

repository: mdoering/backbone

repo_name: mdoering/backbone


text:
---
layout: layouts/post.njk
title: Fading long section
description: Fading long section to indicate there is more content
keywords: css fading overflow, css linear gradient
---

The pattern is often used to indicate there is more content.

## HTML

```html
<div class="fading-long-section">
    <!-- Main content -->
    <div class="fading-long-section__content">...</div>

    <!-- The faded element -->
    <div class="fading-long-section__fading"></div>
</div>
```

## CSS

```css
.fading-long-section {
    /* Used to position the faded element */
    position: relative;
}

.fading-long-section__content {
    /* Height */
    height: 100%;
    overflow-y: hidden;
}

.fading-long-section__fading {
    /* Displayed at the bottom */
    bottom: 0;
    left: 0;
    position: absolute;

    /* Size */
    height: 2rem;
    width: 100%;

    /* Gradient background */
    background: linear-gradient(rgba(255, 255, 255, 0.01), #fff);
}
```

{% demo %}
{% include "covers/fading-long-section.njk" %}
{% enddemo %}

repository: duphungcong/csslayout

repo_name: duphungcong/csslayout


text:
# Hardware abstraction layer

This directory contain platform specific implementation of hardware abstraction layer.

  * arduino dir: for all Arduino platforms (if you use Arduino IDE)
  * avr dir: for plain avr-gcc environment
  * esp dir: for plain esp8266/esp32 environment
  * linux dir: for linux platforms including raspberry pi
  * mingw dir: for running under windows
  * stm32 dir: for plain stm32 support (not implemented)
  * energia dir: for Energia platforms w/ MSP432P401R

Edit UserSettings.h header file, if you want to disable some parts of ssd1306 library to reduce memory consumption in your project

gha_language: C


text:
![Lincense](https://img.shields.io/apm/l/npm)
# <Project>

## Description
        Having good time
        Doing good work
        Making good foods
        School is the best

## Table of Contents
 - [Installation](#installation)
 - [Usage](#usage)
 - [Credits](#credits)
 - [License](#license)
 - [Badges](#badges)
 - [Features](#features)
 - [Contributes](#contributes)
 - [Tests](#tests)
 - [Questions](#questions)

## Installation
        install your npm first

## Usage
        type the node index.js into your terminal
        ![Demo of Work](Demo is in the project README.md)

## Credits
        N/A

## License
        MIT

## Badges
        ![GitHub Language](https://img.shields.io/github/languages/top/anniechen9025/Professional-README-Generator?style=for-the-badge)

## Features
        Able to generate the README.md

## How to Contribute
        N/A

## Tests
        N/A

## Quesrions
        Please feel free to contact:
        Github:https://github.com/anniechen9025/
        Email:anniechen9025@gmail.com


text:
##  Contact Cross-Reference Rebuild Process (CONTACT.P1)

<PageHeader />

**Form Details**
[ Form Details ](CONTACT-P1-1/README.md)

**Purpose**
The CONTACT.P1 procedure rebuilds the name and phone number cross-reference
fields to provide for faster and easier lookups.

**Frequency of Use**
The cross-references is maintained automatically as contact records are
entered. Therefore, the only time you really need to run this procedure is
when the file has been corrupted, or when initially converted.

**Prerequisites**
The name and phone cross reference fields should be indexed in the FDICT.E
procedure.

<badge text= "Version 8.10.57" vertical="middle" />

<PageFooter />

repository: zumasys/docs

repo_name: zumasys/docs


text:
Operator Support
=====================

NVTabular provides operators for preprocessing and feature engineering.  While the initial set is limited, we are currently working to expand upon the available operator set.

Currently support is available for:

| Operator Name | Data Type | Major Options | Description |
| -----------   | --------- | ------------- | ----------- |
| GroupBy       | [Categorical],[Continuous]| min, max, mean, stdev, distance from min, max & mean | For a set of categorical columns, perform a groupby operation on that set and calculate the min, max, mean, stdev, and distance from min, max & mean for one or more continuous variables, including the target variable.  Binary & Ordinal continuous variables are allowed as well.  Lambda as an option here makes sense as well but is slightly more complex.|
| Join          | [Categorical] | left, right, inner, outer | Join a table or file by categorical fields |
| Encoding_Numerical | Categorical | Full, Frequency Filtered | Encodes categories into a contiguous space from 0 to cardinality, reserving 0 for missing/null values.|
| Normalize | Continuous | Standard, MinMax, Mean | Normalizes the data based on the chosen normalization type. |
| Gaussify | Continuous | GaussRank | Transforms the distribution of a continuous variable into a Gaussian |
| Log | Continuous | | Transforms an exponential distribution into one that is linear |
| Fill_Missing | Continuous / Categorical | Fixed Value, Mean, Median (of medians) / Fixed Value, Mode, Unique | Replace missing values in a column with another appropriate value |

repository: alecgunny/NVTabular

repo_name: alecgunny/NVTabular


text:
# Basilica R Client: Deep Feature Extraction for Images and Text

## [Word2Vec For Anything](https://www.basilica.ai)

[Basilica](https://www.basilica.ai) allows you to easily augment your models with images and text. You send
us an image or a snippet of natural language text and we send you a vector of
features you can use to train your models.

## Installation

You can install the released version of this package from Google cloud:

```r
install.packages("https://storage.googleapis.com/basilica-r-client/basilica_0.0.2.tar.gz", repos=NULL)
```

or from Github (requires the `devtools` package):

``` r
devtools::install_github("basilica-ai/basilica-r-client")
```

(CRAN submission approval in progress)

## Examples

This is a basic example which shows you how to solve a common problem:

### Creating a Connection

Before embedding an image or text (getting a vector of features), you must first
connect to the API with a demo key. `SLOW_DEMO_KEY` is a key you can use for
testing with a low per-week limit, but you can create API keys for free at [www.basilica.ai](https://www.basilica.ai/accounts/register/).

``` r
library('basilica')
# Create a connection
# You can use our `SLOW_DEMO_KEY` (it actually works) or create your own at basilica.ai
conn <- connect("SLOW_DEMO_KEY")
```

### Embedding Text

Getting a vector of features for text:

```r
sentences = c(
    "This is a sentence!",
    "This is a similar sentence!",
    "I don't think this sentence is very similar at all..."
)

# Returns a data frame with 512 features for each of the 3 sentences
embeddings <- embed_sentences(sentences, conn=conn)
print(dim(embeddings)) # 3 512
print(embeddings) # [[0.8556405305862427, ...], ...]

print(cor(embeddings[1,], embeddings[2,])) # 0.8048559
print(cor(embeddings[1,], embeddings[3,])) # 0.6877435
```

#### Differences from Word2Vec

It's important to know that the embedding you get for a sentence is completely
different from an embedding you would get with Word2Vec. Word2Vec returns a
word-level embedding, while basilica is trained on longer snippets of natural
language text (phrases, sentences, paragraphs). For that reason, results on models
where the context of the sentence matter (like sentiment analysis) will get much
better results with a sentence-level embedding than with a word embedding.

### Embedding an Image

Getting a vector of features for images:

```r
embeddings <- embed_image("/tmp/image.jpg", conn=conn)
print(dim(embeddings)) # 1 2048
print(embeddings) # [[0.8556405305862427, ...], ...]
```

## Development

If you want to contribute to this client, here's are some of the libraries and
commands you will need:

### Setup

```
brew install qpdf
```

```r
install.packages("devtools")
install.packages("usethis")
install.packages("testthat")
```

### Building

When on a branch, make sure all these commands work and pass.

```
devtools::test()
devtools::document()
devtools::build_vignettes()
devtools::check()
```

repository: basilica-ai/basilica-r-client

gha_language: R

gha_license_id: NOASSERTION

repo_name: basilica-ai/basilica-r-client


text:
---
layout: post
title: "Why you should avoid mean-based imputation"
date: 2019-05-27
excerpt: "single vs multiple imputation"
tags: [regression, R, missing data, imputation]
comments: false
---
<style type="text/css">

h1.title {
  font-size: 38px;
  color: Black;
  font-face: Bold;
}

body, td {
   font-size: 18px;
}
code.r{
  font-size: 16px;
}
pre {
  font-size: 14px
}
</style>
<br>

### **Why to avoid mean imputation (and try multiple imputation instead)**

Anyone who has worked with data has discovered a fun secret: it has the tendency to have bits and pieces missing. That is, an observation may have values for some variables but not for others. A common strategy to deal with missing data is to replace missing values within a variable with the mean. Indeed, mean-imputation is one of the most commond methods for dealing with missing values. On the surface, its easy to see why this is an attractive approach. The original size of the dataset is maintained and the mean of the the variable remains unchanged. However, mean imputation comes with some drawbacks which we'll explore below using the classic iris dataset. As an alternative, we'll explore how multiple imputation can be used in place of mean-imputation focusing in on how estimates across imputed datasets are actually pooled.

    ##   Sepal.Length Sepal.Width Petal.Length Petal.Width Species
    ## 1          5.1         3.5          1.4         0.2  setosa
    ## 2          4.9         3.0          1.4         0.2  setosa
    ## 3          4.7         3.2          1.3         0.2  setosa
    ## 4          4.6         3.1          1.5         0.2  setosa
    ## 5          5.0         3.6          1.4         0.2  setosa
    ## 6          5.4         3.9          1.7         0.4  setosa

    ##              Sepal.Length Sepal.Width Petal.Length Petal.Width
    ## Sepal.Length    1.0000000  -0.1175698    0.8717538   0.8179411
    ## Sepal.Width    -0.1175698   1.0000000   -0.4284401  -0.3661259
    ## Petal.Length    0.8717538  -0.4284401    1.0000000   0.9628654
    ## Petal.Width     0.8179411  -0.3661259    0.9628654   1.0000000

### **Replacing missing values with the mean distorts the relationship among variables**

Specifically, the strength of the relationship between the other variables and the mean-imputed variable will decrease. Below, we'll take the variable "Petal Width" and progressively, randomly remove a percentage of values and observe how that changes it's relationship to other variables in the iris dataset. We'll do this 500 times at each proportion of missingness and average the correlation between "Petal Width" and the 3 other numerical variables in the iris dataset. In this case, mean-imputing even a moderate about of data can have a pretty drastic effect on the relationship stucture of this dataset.

{% capture images %} https://raw.githubusercontent.com/dasilvaa10/dasilvaa10.github.io/master/_posts/2019-05-27-b5-files/unnamed-chunk-4-1.png {% endcapture %} {% include gallery images=images caption="" cols=1 %}

So, if we mean-impute, we distort the relationship structure of the data. What else can go wrong?

### **Mean-imputation leads to reduced variance**

Intuitively this makes sense, you are plopping in the *same* value multiple times. Inherently, variability will be reduced. Once more, we'll take the variable "Petal Width" and progressively, randomly remove a percentage of values and see how variance (SD) is affected. We'll do this 500 times at each proportion of missingness and average the standard deviation of "Petal Width" at each step.

{% capture images %} https://raw.githubusercontent.com/dasilvaa10/dasilvaa10.github.io/master/_posts/2019-05-27-b5-files/unnamed-chunk-5-1.png {% endcapture %} {% include gallery images=images caption="" cols=1 %}

### **If the variance is reduced so is the standard error.**

Statistics (e.g., one sample t-test) using the standard error to compute t-values and p-values will be biased potentially resulting in increased Type 1 error rates. Of course, this is far from ideal.

Solution?

Give multiple imputation a try.

A mean-based imputation is a single imputation strategy. With multiple imputation, several imputed datasets are created to account for the uncertainty in the imputation process. There are many algorithms that can be used to create these imputed datasets. A common number of imputed datasets to create is 5 or 10. Once these datasets are created, they are analyzed separately and their results *pooled* to arrive at a final result.

*Pooling* can be a confusing concept upon first exposure to multiple imputation methods. What (and how) exactly is being pooled? Let's take a look.

The package "mice" is a popular package in R for performing multiple imputation. We'll use it to impute some missing data from the variable "Petal Width". In the "mice" function "m" is equal to the number of datasets we'll be creating (here, m=5 which is the default). To impute, we'll using predictive mean matching which is the default method.

``` r
library(mice)

miss <- prodNA(data.frame(iris$Petal.Width), noNA = .25)

temp.iris<-data.frame(iris[,1:3],miss)

imp.ris <- mice(temp.iris, m = 5,printFlag = FALSE)
```

When looking at the output we can see a few things. As stated above, the number of multiple imputations is equal to 5 and Predictive mean matching (pmm) was used as the imputation method. When looking at the "PredictorMatrix", we can see that all the other variables in the iris dataset were used to create predicted values for "Petal Width".

``` r
imp.ris
```

    ## Multiply imputed data set
    ## Call:
    ## mice(data = temp.iris, m = 5, printFlag = FALSE)
    ## Number of multiple imputations:  5
    ## Missing cells per column:
    ##     Sepal.Length      Sepal.Width     Petal.Length iris.Petal.Width
    ##                0                0                0               37
    ## Imputation methods:
    ##     Sepal.Length      Sepal.Width     Petal.Length iris.Petal.Width
    ##               ""               ""               ""            "pmm"
    ## VisitSequence:
    ## iris.Petal.Width
    ##                4
    ## PredictorMatrix:
    ##                  Sepal.Length Sepal.Width Petal.Length iris.Petal.Width
    ## Sepal.Length                0           0            0                0
    ## Sepal.Width                 0           0            0                0
    ## Petal.Length                0           0            0                0
    ## iris.Petal.Width            1           1            1                0
    ## Random generator seed value:  NA

As an example, let's fit a simple regression model by regressing "Sepal Width" on "Petal Width". Notice how a regression model is fit to each imputed dataset.

``` r
fit <- with(imp.ris, lm(iris.Petal.Width ~ Sepal.Width))
summary(fit)
```

    ##
    ##  ## summary of imputation 1 :
    ##
    ## Call:
    ## lm(formula = iris.Petal.Width ~ Sepal.Width)
    ##
    ## Residuals:
    ##     Min      1Q  Median      3Q     Max
    ## -1.4558 -0.5924 -0.0195  0.5191  1.6712
    ##
    ## Coefficients:
    ##             Estimate Std. Error t value Pr(>|t|)
    ## (Intercept)   3.1188     0.3995   7.807 9.85e-13 ***
    ## Sepal.Width  -0.6361     0.1294  -4.917 2.31e-06 ***
    ## ---
    ## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
    ##
    ## Residual standard error: 0.6883 on 148 degrees of freedom
    ## Multiple R-squared:  0.1404, Adjusted R-squared:  0.1346
    ## F-statistic: 24.18 on 1 and 148 DF,  p-value: 2.308e-06
    ##
    ##
    ##  ## summary of imputation 2 :
    ##
    ## Call:
    ## lm(formula = iris.Petal.Width ~ Sepal.Width)
    ##
    ## Residuals:
    ##      Min       1Q   Median       3Q      Max
    ## -1.46164 -0.58897 -0.03628  0.52470  1.67541
    ##
    ## Coefficients:
    ##             Estimate Std. Error t value Pr(>|t|)
    ## (Intercept)   3.1426     0.4089   7.684 1.95e-12 ***
    ## Sepal.Width  -0.6439     0.1324  -4.862 2.94e-06 ***
    ## ---
    ## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
    ##
    ## Residual standard error: 0.7046 on 148 degrees of freedom
    ## Multiple R-squared:  0.1377, Adjusted R-squared:  0.1319
    ## F-statistic: 23.64 on 1 and 148 DF,  p-value: 2.935e-06
    ##
    ##
    ##  ## summary of imputation 3 :
    ##
    ## Call:
    ## lm(formula = iris.Petal.Width ~ Sepal.Width)
    ##
    ## Residuals:
    ##      Min       1Q   Median       3Q      Max
    ## -1.54853 -0.58223 -0.01657  0.52109  1.66602
    ##
    ## Coefficients:
    ##             Estimate Std. Error t value Pr(>|t|)
    ## (Intercept)   3.0896     0.4062   7.606 3.03e-12 ***
    ## Sepal.Width  -0.6266     0.1315  -4.763 4.50e-06 ***
    ## ---
    ## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
    ##
    ## Residual standard error: 0.6999 on 148 degrees of freedom
    ## Multiple R-squared:  0.1329, Adjusted R-squared:  0.1271
    ## F-statistic: 22.69 on 1 and 148 DF,  p-value: 4.503e-06
    ##
    ##
    ##  ## summary of imputation 4 :
    ##
    ## Call:
    ## lm(formula = iris.Petal.Width ~ Sepal.Width)
    ##
    ## Residuals:
    ##      Min       1Q   Median       3Q      Max
    ## -1.44252 -0.56779 -0.01756  0.53236  1.66973
    ##
    ## Coefficients:
    ##             Estimate Std. Error t value Pr(>|t|)
    ## (Intercept)   3.0796     0.4024   7.654 2.32e-12 ***
    ## Sepal.Width  -0.6248     0.1303  -4.795 3.92e-06 ***
    ## ---
    ## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
    ##
    ## Residual standard error: 0.6933 on 148 degrees of freedom
    ## Multiple R-squared:  0.1345, Adjusted R-squared:  0.1286
    ## F-statistic: 22.99 on 1 and 148 DF,  p-value: 3.924e-06
    ##
    ##
    ##  ## summary of imputation 5 :
    ##
    ## Call:
    ## lm(formula = iris.Petal.Width ~ Sepal.Width)
    ##
    ## Residuals:
    ##      Min       1Q   Median       3Q      Max
    ## -1.43968 -0.57798 -0.03179  0.50663  1.66083
    ##
    ## Coefficients:
    ##             Estimate Std. Error t value Pr(>|t|)
    ## (Intercept)   3.0560     0.4072   7.505  5.3e-12 ***
    ## Sepal.Width  -0.6158     0.1319  -4.670  6.7e-06 ***
    ## ---
    ## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
    ##
    ## Residual standard error: 0.7015 on 148 degrees of freedom
    ## Multiple R-squared:  0.1284, Adjusted R-squared:  0.1225
    ## F-statistic: 21.81 on 1 and 148 DF,  p-value: 6.703e-06

Now, estimates from the five regression models are pooled into 1 final result. But how?

``` r
summary(pool(fit))
```

    ##                    est        se         t       df     Pr(>|t|)
    ## (Intercept)  3.0973100 0.4065569  7.618393 144.4583 3.097966e-12
    ## Sepal.Width -0.6294298 0.1316414 -4.781395 144.5065 4.243603e-06
    ##                  lo 95      hi 95 nmis        fmi      lambda
    ## (Intercept)  2.2937414  3.9008785   NA 0.02178850 0.008338440
    ## Sepal.Width -0.8896212 -0.3692383    0 0.02157884 0.008130352

A common way to pool estimates involves combining the within and between imputation variability. To do this we need to grab the beta estimates and associated variances for each model.

``` r
b<-double()
v<-double()
for(i in 1:5){
b[i]<-fit$analyses[[i]]$coefficients[2]
v[i]<-vcov(fit$analyses[[i]])[2,2]
}

cbind(b,v)
```

    ##               b          v
    ## [1,] -0.6361127 0.01673606
    ## [2,] -0.6438847 0.01753770
    ## [3,] -0.6265744 0.01730438
    ## [4,] -0.6248033 0.01697810
    ## [5,] -0.6157738 0.01738663

Within variance is the average of the variances associated with beta estimates and between variance is a the variability in the beta estimates. The within and between variance are added to the between variance divded by a correction factor equal to the number of imputations (m). We can take the square root of this result to get the pooled standard error.

``` r
within_v<-mean(v)
between_v<-var(b)

sqrt(within_v+between_v+(between_v/5))
```

    ## [1] 0.1316414

### **Is multiple imputation worth the fuss?**

Yep. Let's say we are botanists and wanted to test whether the mean petal width was different than some known value in the field. To do this theoretical one sample t-test we'd need to again pool variances across the imputed datasets. We can do this easily with the function "mi.t.test" from the "MKmisc" package. As before, we'll take the variable "Petal Width" and progressively, randomly remove a percentage of values and see how variance (SD) is affected. We'll perform multiple imputation with predicitive mean matching (m = 5) 500 times at each proportion of missingness and average the standard deviation of "Petal Width" at each step. These results are displayed along with the mean-imputation results from earlier. Note how stable SDs are in the multiply imputed data.

{% capture images %} https://raw.githubusercontent.com/dasilvaa10/dasilvaa10.github.io/master/_posts/2019-05-27-b5-files/unnamed-chunk-13-1.png {% endcapture %} {% include gallery images=images caption="" cols=1 %}

### **Hopefully, you'll think twice about before mean-imputing and give multiple-imputaiton a shot.**

There are of course other ways to handle missing data (e.g., KNN, random forest, etc) and there is no universal gold-standard when it comes to imputation. However, as I've shown, there are some methods (mean-imputation!) you'd do well to stay away from! Before thinking about imputing (or moving forward with the complete cases), its important to consider the structure of missing data whether it be missing completely at random (MCAR), missing at random (MAR), or missing not at random (MNAR) as this should impact your decision to impute (or not).


text:
---
# Documentation: https://wowchemy.com/docs/managing-content/

title: Object Grounding via Iterative Context Reasoning
url_pdf: https://openaccess.thecvf.com/content_ICCVW_2019/papers/MDALC/Chen_Object_Grounding_via_Iterative_Context_Reasoning_ICCVW_2019_paper.pdf
subtitle: ''
summary: 'Accepted to ICCV 2019 Workshop'
authors:
- Lei Chen
- Mengyao Zhai
- Jiawei He
- Greg Mori
tags: []
categories: []
date: '2019-01-01'
lastmod: 2021-03-11T16:32:59-08:00
featured: false
draft: false

# Featured image
# To use, add an image named `featured.jpg/png` to your page's folder.
# Focal points: Smart, Center, TopLeft, Top, TopRight, Left, Right, BottomLeft, Bottom, BottomRight.
image:
  caption: ''
  focal_point: ''
  preview_only: false

# Projects (optional).
#   Associate this post with one or more of your projects.
#   Simply enter your project's folder or file name without extension.
#   E.g. `projects = ["internal-project"]` references `content/project/deep-learning/index.md`.
#   Otherwise, set `projects = []`.
projects: []
publishDate: '2021-03-12T00:32:59.171497Z'
publication_types:
- '1'
abstract: ''
publication: '*1st Workshop on Multi-Discipline Approach for Learning Concepts at
  IEEE International Conference on Computer Vision (ICCV)*'
---

repository: arzelachen/starter-academic

repo_name: arzelachen/starter-academic


text:
Gofreta REST API server
======================================================================

:warning: **This project is no longer actively maintained. Better and more extendable alternative is [PocketBase](https://github.com/pocketbase/pocketbase).**

"Go + Mongo" REST API server implementation for [Gofreta](https://gofreta.com).

- [Installation](#installation)
- [Configurations](#configurations)
- [API Reference](#api-reference)
- [Development](#development)

## Installation

- Install [MongoDB 3.2+](https://www.mongodb.com/download-center?jmp=nav#community) and after that apply the following command to insert an initial user and language items (you can change them later):
  ```bash
  mongo localhost/gofreta --eval '
  var nowTimestamp = Date.now() / 1000 << 0;
  // insert user "admin" with password "123456"
  var adminUser = {"username": "admin", "email"<EMAIL_ADDRESS>"status": "active", "password_hash": "$2a$12$rdX7N6gpAzKJ/7DzCMyVdeRaTUv6faL6GxhTODzlJcuDHRf4hedoO", "reset_password_hash": "", "access": {"user": ["index", "view", "create", "update", "delete"], "key": ["index", "view", "create", "update", "delete"], "language": ["create", "update", "delete"], "media": ["index", "view", "upload", "update", "delete", "replace"], "collection": ["index", "view", "create", "update", "delete"]}, "created": nowTimestamp, "modified": nowTimestamp};
  db.user.insert(adminUser);
  // insert English(en) language
  var language = {"title": "English", "locale": "en", "created": nowTimestamp, "modified": nowTimestamp};
  db.language.insert(language);
  '
  ```

- Download the latest [Gofreta binary release](https://github.com/gofreta/gofreta-api/releases) and place it on your server.
  Execute the binary and specify the environment configuration file (see [Configurations](#configurations)):
  ```bash
  ./gofreta -config="/path/to/config.yaml"
  ```

That's it :). Check the API Reference documentation for info how to use the API.

## Configurations

Here is a yaml config file with the default application configurations:
You can extend it by using the `-config` flag (eg. `-config="/path/to/config.yaml"`).

```yaml
# the API base http server address
host: "http://localhost:8090"

# the Data Source Name for the database
dsn: "localhost/gofreta"

# mail server settings (if `host` is empty no emails will be send)
mailer:
  host:     ""
  username: ""
  password: ""
  port:     25

# these are secret keys used for JWT signing and verification
jwt:
  verificationKey: "__your_key__"
  signingKey:      "__your_key__"
  signingMethod:   "HS256"

# user auth token session duration (in hours)
userTokenExpire: 72

# reset password settings
resetPassword:
  # user reset password token secret
  secret: "__your_secret__"
  # user reset password token valid duration time (in hours)
  expire: 2
  # if not empty, the link will be included in the reset password email
  # (use `<hash>` as a placeholder for the reset password token, eg. `http://example.com/reset-password/<hash>`)
  pageLink: ""

# pagination settings
pagination:
  defaultLimit: 15
  maxLimit:     100

# upload settings
upload:
  maxSize: 5
  thumbs:  ["100x100", "300x300"]
  dir:     "./uploads"
  url:     "http://localhost:8090/upload"

# system email addresses
emails:
  noreply<EMAIL_ADDRESS>  support<EMAIL_ADDRESS>```

> I recommend you to double check the following parameters: `host`, `dsn`, `mailer`, `jwt`, `resetPassword.secret` and `upload`.

## API Reference

Detailed info and response examples are available at the offical Gofreta docs - https://gofreta.com/docs

## Development

#### Docker

Requirements:

- [Docker](https://docs.docker.com/install/)
- [Docker Compose](https://docs.docker.com/compose/install/)

Clone or download the [repository](https://github.com/gofreta/gofreta-api) and execute the following commands:

```
# start the docker daemon service (if is not started already)
sudo systemctl start docker

# navigate to the project root dir
cd /path/to/gofreta-api

# start the project docker services
docker-compose up -d

# fetch and install the dependent packages
./docker/scripts/glide install

# start the API service and listen to `localhost:8090`
./docker/scripts/start
```

For convenience the following helper docker-compose scripts are available:

- **`./docker/scripts/start`** - initialize the API service with the provided `./docker/api/config.yml` configurations
- **`./docker/scripts/glide`** - alias to the api_service glide binary, eg. `./docker/scripts/glide install`
- **`./docker/scripts/go`**    - execute any golang commands within the api_service container, eg. `./docker/scripts/go test ./...`
- **`./docker/scripts/mongo`** - connect to the interactive mongodb shell, eg. `./docker/scripts/mongo`

#### Manual

Requirements:

- [Go 1.6+](https://golang.org/doc/install)
- [MongoDB 3.2+](https://www.mongodb.com/download-center?jmp=nav#community)

To download and install the package, execute the following command:
```bash
# install the application
go get github.com/gofreta/gofreta-api

# install glide (a vendoring and dependency management tool), if you don't have it yet
go get -u github.com/Masterminds/glide

# navigate to the applicatin directory
cd $GOPATH/src/github.com/gofreta/gofreta-api

# fetch and install the dependent packages
$GOPATH/bin/glide install
```

Now you can build and run the application by running the following command:
```bash
# navigate to the applicatin directory
cd $GOPATH/src/github.com/gofreta/gofreta-api

# run the application with the default configurations
go run server.go

# run the application with user specified configuration file
go run server.go -config="/path/to/config.yaml"
```

## Credits

Gofreta REST API is part of [Gofreta](https://gofreta.com) - an Open Source project licensed under the [BSD3-License](LICENSE.md).

Help us improve and continue the project development - [https://gofreta.com/support-us](https://gofreta.com/support-us)

repository: gofreta/gofreta-api

repo_name: gofreta/gofreta-api


text:
# git-hooks

[![Unlicense](https://img.shields.io/badge/license-Unlicense-blue)](https://choosealicense.com/licenses/unlicense/) [![CC0](https://img.shields.io/badge/license-CC0-blue)](https://creativecommons.org/publicdomain/zero/1.0/)

Easily keep git hooks updated.

## How to use

1. Copy `git-hooks/` to your project folder.
2. Add any pre-commit tasks to `git-hooks/pre-commit`. Add any additional hooks as necessary.
3. Run `git-hooks/install-hooks`. This will copy the contents of `git-hooks/` to `.git/hooks/`.

Hooks will be updated upon `commit`, `pull`, `rebase`, etc. To add or edit a hook, add or edit the file in `git-hooks/` and then run `git-hooks/install`.

repository: atomicparade/git-hooks

repo_name: atomicparade/git-hooks


text:
# 03 Layouts

Let's move functionality to `layouts` folder.

We will start from `02-core`.

# Steps to build it

- `npm install` to install previous sample packages:

```bash
npm install
```

- Let's migrate `app.layout`:
  - `components/app.layout.styles.ts` > `layouts/app.layout.styles.ts`:
  - `components/app.layout.tsx` > `layouts/app.layout.tsx`:

_./src/components/index.ts_

```diff
export * from './car-list.container';
- export * from './app.layout';
export * from './car.container';

```

- Add barrel file:

_./src/layouts/index.ts_

```javascript
export * from './app.layout';

```

_./src/pages/cars.tsx_

```diff
import React from 'react';
import useSWR from 'swr';
import Head from 'next/head';
+ import { AppLayout } from 'layouts';
import * as api from '../api';
- import { AppLayout, CarListContainer } from '../components';
+ import { CarListContainer } from '../components';

...

```

_./src/pages/cars/\[carId\].tsx_

```diff
import React from 'react';
import { GetServerSideProps } from 'next';
import Head from 'next/head';
+ import { AppLayout } from 'layouts';
import * as api from '../../api';
- import { AppLayout, CarContainer } from '../../components';
+ import { CarContainer } from '../../components';

...

```

- We can create more layouts, for example for `Login` page.

# About Basefactor + Lemoncode

We are an innovating team of Javascript experts, passionate about turning your ideas into robust products.

[Basefactor, consultancy by Lemoncode](http://www.basefactor.com) provides consultancy and coaching services.

[Lemoncode](http://lemoncode.net/services/en/#en-home) provides training services.

For the LATAM/Spanish audience we are running an Online Front End Master degree, more info: http://lemoncode.net/master-frontend

repository: IreneAragon/master-frontend-lemoncode

repo_name: IreneAragon/master-frontend-lemoncode


text:
This is a collection of plugins that exemplify certain aspects of plugin development with senpy.

The first series of plugins are the `basic` ones.
Their starting point is a classification function defined in `basic.py`.
They all include testing and running them as a script will run all tests.
In ascending order of customization, the plugins are:

* Basic is the simplest plugin of all. It leverages the `SentimentBox` Plugin class to create a plugin out of a classification method, and `MappingMixin` to convert the labels from (`pos`, `neg`) to (`marl:Positive`, `marl:Negative`
* Basic_box is just like the previous one, but replaces the mixin with a custom function.
* Basic_configurable is a version of `basic` with a configurable map of emojis for each sentiment.
* Basic_parameterized like `basic_info`, but users set the map in each query (via `extra_parameters`).
* Basic_analyse\_entry uses the more general `analyse_entry` method and adds the annotations individually.

In rest of the plugins show advanced topics:

* mynoop: shows how to add a definition file with external requirements for a plugin. Doing this with a python-only module would require moving all imports of the requirements to their functions, which is considered bad practice.
* Async: a barebones example of training a plugin and analyzing data in parallel.

All of the plugins in this folder include a set of test cases and they are periodically tested with the latest version of senpy.

Additioanlly, for an example of stand-alone plugin that can be tested and deployed with docker, take a look at: lab.gsi.upm.es/senpy/plugin-example
 bbm


text:
Write out some of your awesome attributes, and use emphasis (like bold or italics) to identify keywords, programming languages, or skills.

*Programming*
_C#_

**Languages**
__English__

_I'm **21** yes_


text:
# substweet

Post GIFs of a video with subtitles to twitter.

# INSTALL
To use this application you need:

- A recent version of [ffmpeg](https://www.ffmpeg.org/download.html)
- Python >= 3.5
- Credentials from [apps.twitter.com](https://apps.twitter.com/)

Got all those things?  Install with:

```bash
pip install https://github.com/cnelson/substweet/archive/master.zip
```

# USAGE
```

usage: substweet [-h] [--delay DELAY] [--thread] [--num NUM] [--state STATE]
               [--fps FPS] [--width WIDTH] [--height HEIGHT] [--ffmpeg FFMPEG]
               video [subtitles]

Post GIFs of a video with subtitles to twitter.

NOTE ON TWITTER SECRETS:

In addition to the options listed below, this program will read
on line from stdin  and expects to find the twitter secrets
required to post to an account in the following space-seperated
format:
<consumer key> <consumer secret> <access key> <access secret>

It's recommended you store these secrets in a file and then pipe it
to the program to avoid exposing secrets via the process table.

touch /tmp/secrets
chmod 600 /tmp/secrets
echo "<consumer key> <consumer secret> <access key> <access secret>" >
/tmp/secrets

substweet video.mp4 < /tmp/secrets

EXAMPLE COMMANDS:

Post as quickly as possible while avoiding rate limits:
    substweet video.mp4

The same, but in a single thread:
    substweet --thread video.mp4

Post one post every hour
    substweent --delay 3600 video.mp4

Post three posts then exit, reading prior state from a file
    substweet --num 3 --state /tmp/state.json video.mp4

Use subtitles from an external file
    substweet video.mp4 subs.srts

FAQ:

My GIFs are too short, why?

    Twitter caps GIFs at 5MB.  This program will shorten GIFs by
    removing frames to stay under this limit.  Try using a smaller
    --fps or --width/--height.

Twitter is yelling at me about rate limits, why?

    Did you set a manual --delay?  It's probably too short.

    This app only makes gifs for parts of the video
    that are subtitled. parts without subtitles will be skipped.

positional arguments:
  video                 The video file to post
  subtitles             The subtitles file (optional, if not specified the
                        video file must have a subtitle track)

optional arguments:
  -h, --help            show this help message and exit
  --delay DELAY         Number of seconds to sleep between posts. If not
                        specified will post as quickly as possible while
                        respecting rate limits. If set to too low of a value
                        you will exceed rate limits and the program will exit
  --thread              Post GIFs in a single thread instead of individual
                        posts
  --num NUM             Make this many posts then exit
  --state STATE         Read/write state information from this file. If state
                        information exists, continue posting from where the
                        left run of this program left off
  --fps FPS             The fps of the GIFs
  --width WIDTH         The width of GIFs in pixels. Set to -1 to autoscale
  --height HEIGHT       The height of GIFs in pixels. Set to -1 to autoscale
  --ffmpeg FFMPEG, -f FFMPEG
                        The full path to ffmpeg binary (optional, if not
                        already in $PATH)
```

repository: cnelson/substweet

repo_name: cnelson/substweet