text:
## Introduction

_emount_ decrypts a data volume for the duration of a command. Using _emount_ as a wrapper, a program that does not have encryption built in can maintain its data encrypted on disk ("at rest"), and only decrypted when it needs to be read or written by its managing program. To use this, you would replace the program in your path with a script that invokes _emount_, passing the program as parameters (examples provided).

_emount_ is a wrapper around [gocryptfs](https://nuetzlich.net/gocryptfs/) ([git](https://github.com/rfjakob/gocryptfs)), which encrypts data with AES-256-GCM and makes unencrypted data available via a fuse-mounted volume. It runs entirely in userspace

## Usage

```sh
    emount --init FOLDER [--from srcFolder]
```

Initialize a new encrypted volume at FOLDER. Either the path FOLDER must not exist or it must be an empty directory. If __srcFolder__ is specified, the volume is populated with a recursive copy from the source folder.

The user is prompted to enter a new password, and the password is rejected if it is too weak (according to the `minEntropy` setting in emount.go)

```sh
    emount --run FOLDER [--mount mountpoint] command args...
```

Run the command (with optional arguments), providing access to decrypted FOLDER mounted in a temporary location. When the command completes, the decrypted volume is unmounted. The 'command' term should be a program in your PATH or an absolute path to an executable.

The default mount point is a dynamically-created temporary folder (inside TMPDIR), owned by the calling user with permission mode 0700. The dynamic folder name is passed to the command executable through the environment variable `EMOUNT_FOLDER`.

The default mount point can be overridden by the --mount/-m flag.

- Tip: When using the `--mount MOUNTPOINT` parameter, it is up to you to ensure that the mountpoint (where unencrypted data will be mounted) has _appropriate_ access permissions, and, for example, is not unintentionally shared across a network.

For automation or to avoid interactive prompting for password, the encryption password can be provided via the environment variable `EMOUNT_PASSWORD`.

## Current status

Tested on Linux (Arch, 5.4+ kernel) and macOS Catalina & BigSur.

If you're getting errors on mocos BigSur related to osxfuse, you need to upgrade osxfuse (now called macfuse) and gocryptfs.
Try `brew reinstall osxfuse`, reboot, then `brew reinstall gocryptfs`.

Please try it out and let me know what you find. This program should be considered beta status. Always keep backups.
Feedback is welcome.

## Setup and Examples

### Installation

- Prerequisites: Install [gocryptfs](https://github.com/rfjakob/gocryptfs), which in turn requires fuse.
On Mac BigSur, you need [macfuse](https://osxfuse.github.io) v4+.

After installation or upgrade of fuse, reboot to ensure the drivers are loaded.

- Install emount

    ```sh
    go get github.com/stevelr/emount
    ```

- ensure emount (possibly in $HOME/go/bin or $GOPATH/go/bin) is in your PATH

### Quick demo

Here are a few commands you can do to test the installation:

```sh
# create a volume with -i/--init. You will be prompted to enter a new password
emount -i /tmp/emtest
# each time you run a program you will be prompted for the password again.
# For this demo, we'll run an interactive bash session.
emount -r /tmp/emtest bash

        # Now you are running a subshell, with the decrypted folder mounted at:
        cd $EMOUNT_FOLDER
        ls
        # It's empty, since we just created the vault.
        # Print the directory path so we can check it later
        pwd
        # create a simple file
        echo hello > abc.txt
        ls -al
        exit

# if you look in /tmp/emtest now, you will see two gocryptfs files, and one more
# with an obscure name with about 22 random characters. That's abc.txt with
# an encrypted file name.
# If you look in the folder that was mounted as $EMOUNT_FOLDER,
# it will be empty, since it's not mounted anymore.

# Quickly decrypt and view the contents of abc.txt. You will be prompted for password
emount -r /tmp/emtest bash -c "cat \$EMOUNT_FOLDER/abc.txt"
# The command above decrypts the vault, mounts the folder,
# runs the bash command, and unmounts, effectively "sealing" the vault again.
```

- If you want to avoid having to re-type the password, you can set it as an environment variable "EMOUNT_PASSWORD".

### Joplin and Joplin-desktop (linux/mac)

An example setup for [Joplin](https://joplinapp.org/), an awesome markdown editor, is documented in [example-joplin.md](./example-joplin.md)

## Notes

### Backups

You can back up the encrypted folder using standard backup tools. It is recommended to run backups only when the owning program is not running (e.g, the decrypted volume is not mounted).

### How secure/private is this?

The algorithms used, [AES-256-GCM](https://en.wikipedia.org/wiki/Galois/Counter_Mode) for encryption, and [HKDF-SHA256](https://en.wikipedia.org/wiki/HKDF) for key derivation, are well regarded by many cryptography experts. File names are also encrypted. gocryptfs has published results of a [2017 external security audit](https://defuse.ca/audits/gocryptfs.htm). There is a lot of good material on [gocryptfs's wiki](https://nuetzlich.net/gocryptfs/) including discussion of algorithms used and thread model.

- Unsolicited security tips:
  - One of the weakest links is the choice of password used. Even though the password is salted and hashed, weak passwords are easier to crack. Choose a good one! There is a minimum entropy parameter that can be set if you want to ensure that any passwords used have a reasonable level of crack-resistance.
  - If you do make use of the environment variable EMOUNT_PASSWORD to set the password, don't initialize the variable from a text file that sits on the same drive as the encrypted volume - that defeats the purpose of data encrypted on disk.

### Command-line vs gui apps

Because _emount_ prompts the user for password, it needs to have a way to prompt the user and accept typed response. I've only used this app on the command line. It would certainly be possible to make a gui version of this to show a dialog, and hook it into the .desktop apps for linux. I'm open to discussing PRs if somebody wants to work on it.

## Acknowledgements

- [gocryptfs](https://github.com/rfjakob/gocryptfs) The [documentation](https://nuetzlich.net/gocryptfs/) has a description of cryptographic algorithms used and other background.
- [zxcvbn](https://github.com/nbutton23/zxcvbn-go) password strength checking [algorithm](https://github.com/dropbox/zxcvbn) implemented in go

repository: stevelr/emount

repo_name: stevelr/emount


text:
# hugo-smorg

* Demo site: https://solutionroute.github.io/demo/hugo-smorg/
* Author's Site: [https://mikewatkins.ca/](https://mikewatkins.ca/)

Hugo-smorg (small-org? smorgasbord?) is a responsive mobile-first
[Bulma][]-powered, reasonably minimalistic [Hugo][] (https://gohugo.io/) theme
for an individual blogger or a small organization to adapt as need be.

**Current release**: v0.7, April 4 2018 - see [CHANGELOG](./CHANGELOG.md); this
project is being updated daily at present - following HEAD is best. If you are
using the theme and spot issues or areas for improvement please let me know by
opening an issue or submitting a PR.

An ongoing work in progress, I'm using Hugo-Smorg as a base for other projects.

## Objectives

* Remain easy to understand while also being easy to extend.
* Keep pace with current [Hugo][] features and practicies.
* Avoid relying on config.yaml for too much customization.
* Keep HTML customizability effort low using template blocks and partials and
  CSS customizability options open via SASS / CSS.
* Produce output that will validate and load quickly by default.

## Features

Hugo-smorg is:

* Mobile first thanks to [Bulma][], a SASS CSS framework alternative to
  Bootstrap.
* Themable itself via [Bulmaswatch][].
* Minimalistic in nature.

And offers:

* Responsive site-wide drop-down capable navigation menu
* Simple "Subsection" pages possible with layout:subsection in front-matter.
* Breadcrumb-menu in subsection layout, available to others.
* Produces Atom syndication format with option to disable RSS.
* JSON-LD microdata
* Category and Tag taxonomies (partial page-meta)
* Themed mobile-friendly pagination.
* Includes syntax highlighting with a choice of colour themes.
* By default uses zero-wait modern system font stacks; easy integration with
  a webfont via a couple lines of SASS and `npm run scss:min`.

## Screenshot

<img src="https://raw.githubusercontent.com/solutionroute/hugo-smorg/master/images/tn.png" width="900" height="600" style="border: 1px solid grey">

See the [demo site][] for a live view.

## Installation

1. Clone the repo:

	git clone --recursive https://github.com/solutionroute/hugo-smorg.git

2. To view the theme:

	cd exampleSite
	hugo server

3. (Optionally) install development dependencies:

To adapt the provided SASS produced CSS you'll need to install SASS and Bulma
at the very least; the least painful way to go about this is via Nodejs and
npm; Once those tools are installed, in the hugo-smorg theme directory:

	npm install

This will install the dependencies listed in _package.json_ including Bulma and
node-sass. You'll also find some handy run scripts including `npm run dev`
which will build your site and SCSS/CSS files and reload automatically.

[Hugo]: https://gohugo.io/
[demo site]: https://solutionroute.github.io/demo/hugo-smorg/
[Bulma]: https://bulma.io/
[Bulmaswatch]: https://jenil.github.io/bulmaswatch/

license: MIT

repository: tiigbg/entermolndal

branch_name: refs/heads/master

extension: md

gha_language: CSS

license_type: permissive

repo_name: tiigbg/entermolndal


text:
---
layout: default
---

# 1994-04-23 - Remailers

## Header Data

From: David Merriman<EMAIL_ADDRESS>To<EMAIL_ADDRESS>(cypherpunks)

Message Hash: a50862e83f8f2c7ea1aa652b86a0fa139f61e5411e1778ee9eeac85dadf428a2

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1994-04-23 23:05:43 UTC

Raw Date: Sat, 23 Apr 94 16:05:43 PDT

## Raw message

```
{% raw  %}From: David Merriman<EMAIL_ADDRESS>Date: Sat, 23 Apr 94 16:05:43 PDT
To<EMAIL_ADDRESS>(cypherpunks)
Subject: Remailers
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

I 'know' that a decent remailer will time-delay forwarding messages so as
to throw sand in the gears of traffic analysis.  I wonder if it wouldn't
help more if the remailer(s) were set up so that people could send 'dummy'
messages to them.
That is, say I wanted to ensure that traffic analysis on myself were made
as difficult as possible.  I could Email something to a remailer with an
embedded 'flag' or code (ex: blackhole, disposal, trash, etc) telling it
to forward the message to the Bitbucket.  Alternatively, I could include
some other code or flag (ex: rubber, bounce, ricochet, etc) telling it to
take the included (dummy) data, scramble it some, and return it some
random time later.
Alternatively, the remailer could take a so-tagged message, generate some
random data of similar size, and send it (along with my address) to
another remailer that it knew about, which would generate *different*
random data, and sent that back to me.

Wouldn't something like this further complicate traffic analysis, or would
it just constipate the net?

gha_license_id: MIT


text:
# GitIncrementalStore

An NSIncrementalStore subclass that stores its data in a git repository.

## API

For now, just a quick example extracted from the Unit Tests.

```objc
- (void) setUp
{
	// Put each test in it’s own repository
	self.url = [[NSURL fileURLWithPath:NSTemporaryDirectory()] URLByAppendingPathComponent:NSStringFromSelector(self.selector)];
	[[NSFileManager defaultManager] removeItemAtURL:self.url error:nil];

	NSManagedObjectModel * model = [NSManagedObjectModel mergedModelFromBundles:@[ [NSBundle bundleForClass:self.class] ]];
	NSPersistentStoreCoordinator * persistentStoreCoordinator = [[NSPersistentStoreCoordinator alloc] initWithManagedObjectModel:model];

	NSError * error = nil;
	[persistentStoreCoordinator addPersistentStoreWithType:GitIncrementalStore.type configuration:nil URL:self.url options:nil error:&error];
	XCTAssertNil(error, @"Couldn’t create the GitIncrementalStore: %@", error.localizedDescription);

	self.managedObjectContext = [[NSManagedObjectContext alloc] init];
	[self.managedObjectContext setPersistentStoreCoordinator:persistentStoreCoordinator];
	XCTAssertNotNil(self.managedObjectContext, @"NSManagedObjectContext not created.");
}

- (void) tearDown
{
	self.managedObjectContext = nil;
	self.url = nil;
}
```

More documentation will come…

## License (MIT)

Copyright (c) 2013 Bryan Woods

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.

repository: bwoods/GitIncrementalStore

repo_name: bwoods/GitIncrementalStore


text:
## 8.0.0

* Changed from `lev_routine active_job_queue: :some_other_queue` to `lev_routine active_job_enqueue_options: { queue: :some_other_queue }`


text:
# Development Scripts

* `scripts/install` - Install dependencies in a virtual environment.
* `scripts/test` - Run the test suite.
* `scripts/lint` - Run the automated code linting/formatting tools.
* `scripts/check` - Run the code linting, checking that it passes.
* `scripts/coverage` - Check that code coverage is complete.
* `scripts/build` - Build source and wheel packages.
* `scripts/publish` - Publish the latest version to PyPI.

Styled after GitHub's ["Scripts to Rule Them All"](https://github.com/github/scripts-to-rule-them-all).

repository: encode/starlette

gha_language: Python

repo_name: encode/starlette


text:
# Study-Notes-Quiz-App

Generating (Imporant) Questions from Study Notes. This was developed as a part of the final course project for the Natural Language Processing (2021) course at IITH.

Install Expo and use "expo start" to run the mobile app.

WebApp— https://ballofquestions.web.app/
Google Play Link— https://play.google.com/store/apps/details?id=com.ballofwisdom.ballofquestions

repository: thecodearrow/StudyNotesQuizApp

branch_name: refs/heads/main

repo_name: thecodearrow/StudyNotesQuizApp


text:
# SkeletonScore

A plugin for [MuseScore]. Quickly add line breaks, page breaks, and section
breaks to a score to match the layout of a PDF or paper edition.

[MuseScore]: https://musescore.org/ "Open source music notation editor"

## Instructions

The plugin opens a dialog with a text field where you can write your layout in
code form, such as:

```
4 5 4
3 4
```

Each row of numbers represents a page of music in the score, and each number
represents the number of measures in one system.

The code basically means:

- Skip __4 measures__ and add a __line break__
- Skip __5 measures__ and add a __line break__
- Skip __4 measures__ and add a __page break__ (i.e. create a 2nd page)
- Skip __3 measures__ and add a __line break__
- The final system contains __4 measures__.

The type of layout break used is determined by the whitespace character(s)
immediately following each number. The possible values are:

- __Space__ (` `) - adds a line break
- __Newline__ (`\n`) - adds a page break
- __Double newline__ (`\n\n`) - adds a section break

repository: shoogle/MuseScore-plugin-SkeletonScore

repo_name: shoogle/MuseScore-plugin-SkeletonScore


text:
<div align='justify'>

# **Currency Bot Conversor**

![LICENSE] ![ISSUES] ![FORKS] ![STARS]

> A simple bot to convert currencies using Node JS and Puppeteer.

## **About the Project**

This is a simple script that uses Google search to convert currencies. A simulation of searching google through the browser, however, using the terminal.

The parameters passed through the terminal are sent to the browser query string and the result is fetched through the input selector css.

The aim of the project is to study how puppertee works and start developing scripts for automation using web scrapping.

## **Preview**

![](./.github/preview.gif)

## **Getting Started**

install the repository dependencies:

```bash
npm install
```

Start script:

```bash
npm run start
```

Testing:

```bash
npm run test
```

## **Techs**

- [nodejs](https://nodejs.org/)
- [puppertee](https://github.com/puppeteer/puppeteer)
- [colors](https://www.npmjs.com/package/colors)
- [readline-sync](https://www.npmjs.com/package/readline-sync)
- [intl](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat)

## **License**

[MIT](./LICENSE) © Maurício Romagnoli.

</div>

<!-- BADGES -->

[LICENSE]: https://img.shields.io/github/license/x0n4d0/currency-bot-conversor

[ISSUES]: https://img.shields.io/github/issues/x0n4d0/currency-bot-conversor

[FORKS]: https://img.shields.io/github/forks/x0n4d0/currency-bot-conversor

[STARS]: https://img.shields.io/github/stars/x0n4d0/currency-bot-conversor


text:
---
layout: default
---

# 1993-11-12 - Re: Should we oppose the Data Superhighway/NII?

## Header Data

From<EMAIL_ADDRESS>(Doug Merritt)

To<EMAIL_ADDRESS>Message Hash: 459a933e00c910bfed3d4fa2559f296bcbe1f773adc037f024c7948ece0bc617

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1993-11-12 06:59:23 UTC

Raw Date: Thu, 11 Nov 93 22:59:23 PST

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Doug Merritt)
Date: Thu, 11 Nov 93 22:59:23 PST
To<EMAIL_ADDRESS>Subject: Re: Should we oppose the Data Superhighway/NII?
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

"Perry E. Metzger"<EMAIL_ADDRESS>said:
>A single fiber optic strand has enough capacity in theory to carry the
>equivalent of every call made in the U.S. during the peak capacity
>utilization period on Mother's Day.

This is a nice reduction to theory; the current optical modulation rates
fall vastly short of the theoretical limits, but yes, at their maximum
it would be something on that order.

>I don't know about you, but I personally can't produce more than 750
>simultaneous videos at once for network distribution, so I suppose I'm
>uninteresting, but even the people who can do more than that are
>likely going to be fine. If they aren't, well, I suppose they could
>get TWO fibers coming into their home, or maybe even TEN or ONE
>HUNDRED if necessary.

Heh. Well. By today's standards, theoretical-capacity fiber optic will
be indeed be overkill; there would be plenty left over.

Keeping in mind that we're talking about the medium to long term future
rather than the immediate future, though: needs tend to grow easily
as fast as does capacity to meet needs. In the past one can point to
1950's quotes about how many computers would ever be needed worldwide,
or to 1970's arguments about why GUI interfaces would never be realistic,
or even to Bill Joy's late 1980's Nanotech Conf. talk when he coined the unit
of VAX-MIPS-Millenia, which he thought would be useless even if available.

Counterexamples to Joy's thesis are trivially found in cryptography,
and less obviously in things like computer generated holography. The latter
might easily become a GUI standard of the future, and will indeed require
VAX-MIPS-millenia of computation to compute in real time.

They would also require similarly astronomical amounts of bandwidth to
transmit. By today's standards, that's ridiculous to assume. But by the
standards of 10 years hence, two dimensional video may well appear as
primitive as 110 baud text transmission does to us today.

Judging the future by today's standards tends to leave one's predictions
high and dry.
	Doug

{% endraw %}
```

## Thread

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

+ Return to<EMAIL_ADDRESS>(Doug Merritt)](/authors/doug_at_netcom_com_doug_merritt_)"
+ Return to "["Perry E. Metzger" <pmetzger@lehman.com>](/authors/perry_e_metzger_pmetzger_at_lehman_com_)"

+ _Unknown thread root_
  + 1993-11-12 (Thu, 11 Nov 93 22:59:23 PST) - Re: Should we oppose the Data Superhighway/NII? -<EMAIL_ADDRESS>(Doug Merritt)_
    + 1993-11-12 (Fri, 12 Nov 93 08:29:32 PST) - [Re: Should we oppose the Data Superhighway/NII?](/archive/1993/11/c6616be821c019046047994919528fd240fcc5e63c9fbc112047b9cfce7f8ebc) - _"Perry E. Metzger"<EMAIL_ADDRESS>


text:
# Quick Start

This is a set of simple tests to use DeepReg command line tools. More details and other
options can be found in [Command Line Tools](../docs/cli.html).

First, [install DeepReg](install.html) and change current directory to the root
directory of DeepReg.

## Train a registration network

Train a registration network using unpaired and labeled example data with a predefined
configuration:

```bash
deepreg_train --gpu "" --config_path config/unpaired_labeled_ddf.yaml --exp_name test
```

where:

- `--gpu ""` indicates using CPU. Change to `--gpu "0"` to use the GPU at index 0.
- `--config_path <filepath>` specifies the configuration file path.
- `--log_dir test` specifies the output folder. In this case, the output is saved in
  `logs/test`.

## Evaluate a trained network

Once trained, evaluate the network using a test dataset:

```bash
deepreg_predict --gpu "" --ckpt_path logs/test/save/ckpt-2 --split test
```

where:

- `--ckpt_path <filepath>` specifies the checkpoint file path.
- `--split test` specifies prediction on the test dataset.

## Warp an image

DeepReg provides a command line interface (CLI) tool to warp an image/label with a dense
displacement field (DDF):

```bash
deepreg_warp --image data/test/nifti/unit_test/moving_image.nii.gz --ddf data/test/nifti/unit_test/ddf.nii.gz --out logs/test_warp/out.nii.gz
```

where:

- `--image <filepath>` specifies the image/label file path.
- `--ddf <filepath>` specifies the ddf file path.
- `--out <filepath>` specifies the output file path.

repository: DeepRegNet/DeepReg

repo_name: DeepRegNet/DeepReg


text:
## Performing sequence coverage analysis

By delangel

Overview

This document describes the tools and concepts involved in performing sequence coverage analysis, where the purpose is to answer the common question: "(Where) Do I have enough sequence data to be empowered to discover variants with reasonable confidence?".

The tools involved are the following:

DepthOfCoverage: for QC'ing coverage in whole-genome data (WGS)

DiagnoseTargets: for QC'ing coverage in exome data (WEx)

For an overview of the major annotations that are used by variant callers to express read depth at a variant site, and guidelines for using those metrics to evaluate variants, please see this document.

Introduction to coverage analysis as a QC method

Coverage analysis generally aims to answer the common question: "(Where) Do I have enough sequence data to be empowered to discover variants with reasonable confidence?".

This section is incomplete.

Using DepthOfCoverage to QC whole-genome data

DepthOfCoverage is a coverage profiler for a (possibly multi-sample) bam file. It uses a granular histogram that can be user-specified to present useful aggregate coverage data. It reports the following metrics over the entire .bam file:

Total, mean, median, and quartiles for each partition type: aggregate

Total, mean, median, and quartiles for each partition type: for each interval

A series of histograms of the number of bases covered to Y depth for each partition type (granular; e.g. Y can be a range, like 16 to 22)

A matrix of counts of the number of intervals for which at least Y samples and/or read groups had a median coverage of at least X

A matrix of counts of the number of bases that were covered to at least X depth, in at least Y groups (e.g. # of loci with ≥15x coverage for ≥12 samples)

A matrix of proportions of the number of bases that were covered to at least X depth, in at least Y groups (e.g. proportion of loci with ≥18x coverage for ≥15 libraries)

That last matrix is key to answering the question posed above, so we recommend running this tool on all samples together.

Note that DepthOfCoverage can be configured to output these statistics aggregated over genes by providing it with a RefSeq gene list.

DepthOfCoverage also outputs, by default, the total coverage at every locus, and the coverage per sample and/or read group. This behavior can optionally be turned off, or switched to base count mode, where base counts will be output at each locus, rather than total depth.

To get a summary of coverage by each gene, you may supply a refseq (or alternative) gene list via the argument

-geneList /path/to/gene/list.txt

The provided gene list must be of the following format:

585     NM_001005484    chr1    +       58953   59871   58953   59871   1       58953,  59871,  0       OR4F5   cmpl    cmpl    0,
587     NM_001005224    chr1    +       357521  358460  357521  358460  1       357521, 358460, 0       OR4F3   cmpl    cmpl    0,
587     NM_001005277    chr1    +       357521  358460  357521  358460  1       357521, 358460, 0       OR4F16  cmpl    cmpl    0,
587     NM_001005221    chr1    +       357521  358460  357521  358460  1       357521, 358460, 0       OR4F29  cmpl    cmpl    0,
589     NM_001005224    chr1    -       610958  611897  610958  611897  1       610958, 611897, 0       OR4F3   cmpl    cmpl    0,
589     NM_001005277    chr1    -       610958  611897  610958  611897  1       610958, 611897, 0       OR4F16  cmpl    cmpl    0,
589     NM_001005221    chr1    -       610958  611897  610958  611897  1       610958, 611897, 0       OR4F29  cmpl    cmpl    0,

For users who have access to internal Broad resources, the properly-formatted file containing refseq genes and transcripts is located at

/humgen/gsa-hpprojects/GATK/data/refGene.sorted.txt

If you do not have access (if you don't know, you probably don't have it), you can generate your own as described here.

If you supply the -geneList argument, DepthOfCoverage will output an additional summary file that looks as follows:

Gene_Name     Total_Cvg       Avg_Cvg       Sample_1_Total_Cvg    Sample_1_Avg_Cvg    Sample_1_Cvg_Q3       Sample_1_Cvg_Median      Sample_1_Cvg_Q1
SORT1    594710  238.27  594710  238.27  165     245     330
NOTCH2  3011542 357.84  3011542 357.84  222     399     &gt;500
LMNA    563183  186.73  563183  186.73  116     187     262
NOS1AP  513031  203.50  513031  203.50  91      191     290

Note that the gene coverage will be aggregated only over samples (not read groups, libraries, or other types). The -geneList argument also requires specific intervals within genes to be given (say, the particular exons you are interested in, or the entire gene), and it functions by aggregating coverage from the interval level to the gene level, by referencing each interval to the gene in which it falls. Because by-gene aggregation looks for intervals that overlap genes, -geneList is ignored if -omitIntervals is thrown.

Using DiagnoseTargets to QC whole-exome data

DiagnoseTargets produces a pseudo-VCF file that provides a "CallableStatus" judgment for each position or range of positions in the input bam file. The possible judgments are as follows:

PASS : The base satisfied the min. depth for calling but had less than maxDepth to avoid having EXCESSIVE_COVERAGE.

COVERAGE_GAPS : Absolutely no coverage was observed at a locus, regardless of the filtering parameters.

LOW_COVERAGE : There were less than min. depth bases at the locus, after applying filters.

EXCESSIVE_COVERAGE: More than -maxDepth read at the locus, indicating some sort of mapping problem.

POOR_QUALITY : More than --maxFractionOfReadsWithLowMAPQ at the locus, indicating a poor mapping quality of the reads.

BAD_MATE : The reads are not properly mated, suggesting mapping errors.

NO_READS : There are no reads contained in the interval.

repository: michaelSkaro/gatk-docs

repo_name: michaelSkaro/gatk-docs


text:
---
id: eQ5w4eqHrf4m1peq
title: NextJS Template
desc: ''
updated:<PHONE_NUMBER>963
created:<PHONE_NUMBER>918
---

## Summary
- [[Experimental 🧪|dendron.ref.status#experimental-🧪]]

The Dendron NextJS Template is the basis for Dendron's new publishing platform. It is build around NextJS and React.

Google Chrome - localhost:3000/notes/b0fe6ef7-1553-4280-bc45-a71824c2ce36 - Watch Video

## MVP Milestones

The NextJS Template is currently in alpha.

### Features
-   Handle navigating to home page
  -   Tree View
  -   URL
-   Fixed Header
-   Responsive side bar
-   SEO options
-   Edit on Github Link

### Enhancements
-   Clicking on item in nav bar shoudl show spinner
-   Make Lookup change value when navigating
-   Make Breadcrumb clickable

### Fixes
-   Deeply nested tree view items can overflow
-   Opening one child of tree view should not close existing children

repository: namjul/dendron-site

repo_name: namjul/dendron-site


text:
# Rust FUSE - Filesystem in Userspace

[![Build Status](https://travis-ci.org/zargony/rust-fuse.svg?branch=master)](https://travis-ci.org/zargony/rust-fuse)
[![Crates.io](https://img.shields.io/crates/v/fuse.svg)](https://crates.io/crates/fuse)
[![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/zargony/rust-fuse/blob/master/LICENSE.md)

## Feature

 * rust-mount
Using rust-mount remove libfuse.so compilation, rust-fuse in using 100% of rust

## About

[Rust](http://rust-lang.org/) library for easy implementation of [FUSE](http://osxfuse.github.io) filesystems in userspace.

This library does not just provide bindings, it is actually an improved rewrite of the original FUSE C library to fully take advantage of Rust's architecture.

## Documentation

[Rust-FUSE reference](https://docs.rs/fuse)

## Details

A working FUSE filesystem consists of three parts:

1. The kernel driver that registers as a filesystem and forwards operations into a communication channel to a userspace process that handles them.
1. The userspace library (libfuse) that helps the userspace process to establish and run communication with the kernel driver.
1. The userspace implementation that actually processes the filesystem operations.

The kernel driver is provided by the FUSE project, the userspace implementation needs to be provided by the developer. This Rust library provides a replacement for the libfuse userspace library between these two. This way, a developer can fully take advantage of the Rust type interface and runtime features when building a FUSE filesystem in Rust.

Except for a single setup (mount) function call and a final teardown (umount) function call to libfuse, everything runs in Rust.

## Usage

Put this in your `Cargo.toml`:

```toml
[dependencies]
fuse = "0.3"
```

and in your crate root:

```rust
extern crate fuse;
```

To create a new filesystem, implement the trait `Filesystem`. Filesystem operations from the kernel are dispatched to the methods of the `Filesystem` trait. Most methods get a `reply` parameter that must be used to eventually answer the request. All methods have default implementations that reply with neutral answers, so if you implement no method at all, you still get a mountable filesystem that does nothing.

To actually mount the filesystem, pass an object that implements `Filesystem` and the path of an (existing) mountpoint to the `mount` function. `mount` will not return until the filesystem is unmounted.

To mount a filesystem and keep running other code, use `spawn_mount` instead of `mount`. `spawn_mount` spawns a background thread to handle filesystem operations while the filesystem is mounted. It returns a handle that should be stored to reference the mounted filesystem. If the handle is dropped, the filesystem is unmounted.

To unmount a filesystem, use any arbitrary unmount/eject method of your OS.

See the examples directory for some basic examples.

## To Do

There's still a lot of stuff to be done. Feel free to contribute.

- Interrupting a filesystem operation isn't handled yet.
- An additional more high level API would be nice. It should provide pathnames instead inode numbers and automatically handle concurrency and interruption (like the FUSE C library's high level API).

In general, see the [list of issues](https://github.com/zargony/rust-fuse/issues) on GitHub and search the source files for comments containing "TODO" or "FIXME" to see what's still missing.

### Android

- You will provide arm version of libfuse.so in $NDK_HOME/platforms/android-18/arch-arm/usr/lib/
- Replace android-18 by anything you want

## Compatibility

Developed and tested on Mac OS X with [OSXFUSE](http://osxfuse.github.io) and on Linux with [FUSE](http://fuse.sourceforge.net), using stable, beta and nightly [Rust versions](http://www.rust-lang.org/install.html) (see [Travis CI](https://travis-ci.org/zargony/rust-fuse) for details).

Support for [FUSE on FreeBSD](https://wiki.freebsd.org/FuseFilesystem) is currently untested (but probably works with minor adjustments).

repository: Seed-Up/rust-fuse

gha_language: Rust

repo_name: Seed-Up/rust-fuse


text:
# The Michigan WolvMarine, Michigan's Maritime RobotX Team

This is the central code repository for the Michigan Maritime RobotX team and
the WolvMarine. The current setup utilizes ROS Kinetic and Ubuntu 16.04 LTS.

## Contents

The contents of this repository are as follows:
- `deploy/` contains instructions and scripts for field deployment of the
  WolvMarine.
- `setup/` contains instructions and scripts for setting up the WolvMarine and
  its constituent parts. This includes setting up the remote as base computers,
  Arduino boards, network devices, etc.
- `wolvmarine_ws/` is the catkin workspace for the WolvMarine and contains its
  ROS packages.

## Field deployment

TBD

## Action items

Each of the contained folders details more specific action items. The following
are larger considerations given lessons learned from the past competition.

- Develop field deployment scripts and documentation.

- Consider moving the INS sensor. For navigation, it is important that the
  center of the robot is placed at the rotational center of the robot. To
  reduce excessive movement noise, the INS should be placed  the base_link be paced at the center of floatation?

- Robust remote control solution.

  The current setup utilizes an Xbox-style controller whose inputs are funneled
  through the base computer to the remote computer and the to the Arduino acting
  as a motor controller. The communication occurs via a TCP socket, which
  sacrifices speed to prioritize completeness. In addition, joystick commands
  are posted to a ROS topic, but only as the commands change. This causes issues
  when packets are lost.

  During the competition, wireless networks, bandwidths, and center fequencies
  were not controlled by the competition's leadership. As such, wireless
  communication became a battle of who has the highest powered base-station
  antenna. Our performance suffered due to these network issues given that our
  remote control setup was using TCP.

  Two immediate solutions would be (1) to implement a UDP socket for sending
  remote control commands, or (2) have

- Adopt the taxonomy of *remote* and *base* computers, rather than referring to
  them by *puget* and *dell*.

- Adopt the platform name of WolvMarine in the documentation, rather than
  referring to it as the WAM-V.

- Setup auto-generation documentation software, such as sphinx. This would allow
  us to comment only once, in the code. For example, each of the developed ROS
  nodes may accept a set of parameters. The documentation for these parameters
  should be given in file that initializes the node, rather than including
  definitions in separate parameter files.

- Parameter files should be avoided from now on. In some cases, they make sense,
  but in most others, it is clearer to use the `rosparam` tag when spinning up
  a node in a launch file.

- It may be better to consolidate the descriptions and action items from the
  multiple `README`'s.

repository: mikedef/wamv

repo_name: mikedef/wamv


text:
# kneed

## Knee-point detection in Python

[![Downloads](https://pepy.tech/badge/kneed)](https://pepy.tech/project/kneed) [![Downloads](https://pepy.tech/badge/kneed/month)](https://pepy.tech/project/kneed) [![Binder](https://mybinder.org/badge.svg)](https://mybinder.org/v2/gh/arvkevi/kneed/master)  [![Build Status](https://travis-ci.com/arvkevi/kneed.svg?branch=master)](https://travis-ci.com/arvkevi/kneed) [![Codacy Badge](https://api.codacy.com/project/badge/Grade/0438592c8c0949fa902b2665a8b73ff1)](https://www.codacy.com/app/arvkevi/kneed?utm_source=github.com&utm_medium=referral&utm_content=arvkevi/kneed&utm_campaign=Badge_Grade)

This repository is an attempt to implement the kneedle algorithm, published [here](https://www1.icsi.berkeley.edu/~barath/papers/kneedle-simplex11.pdf). Given a set of `x` and `y` values, `kneed` will return the knee point of the function. The knee point is the point of maximum curvature.

![](images/functions_args_summary.png)

## Installation

To install use pip:

     $ pip install kneed

Or clone the repo:

     $ git clone https://github.com/arvkevi/kneed.git
     $ python setup.py install
**Tested with Python 3.5 and 3.6**

## Usage

### Reproduce Figure 2 from the paper.

```python
from kneed import DataGenerator, KneeLocator

DG = DataGenerator()
x,y = DG.figure2()

print(x,y)
(array([ 0.        ,  0.11111111,  0.22222222,  0.33333333,  0.44444444,
         0.55555556,  0.66666667,  0.77777778,  0.88888889,  1.        ]),
 array([-5.        ,  0.26315789,  1.89655172,  2.69230769,  3.16326531,
         3.47457627,  3.69565217,  3.86075949,  3.98876404,  4.09090909]))

kneedle = KneeLocator(x, y, S=1.0, curve='concave', direction='increasing')

kneedle.knee
0.22222222222222221

kneedle.plot_knee_normalized()
```

![](images/figure2.knee.png)

#### Average Knee from 5000 NoisyGaussians when mu=50 and sigma=10

```python
import numpy as np

knees = []
for i in range(5000):
    x,y = DG.noisy_gaussian(mu=50, sigma=10, N=1000)
    kneedle = KneeLocator(x, y, curve='concave', direction='increasing')
    knees.append(kneedle.knee)

np.mean(knees)
60.921051806064931
```

## Application

## Find the optimal number of clusters (k) to use in k-means clustering

See the tutorial in the notebooks folder, this can be achieved with the `direction` keyword argument:

```python
KneeLocator(x, y, curve='convex', direction='decreasing')
```

![](images/knee.png)

Contributing

* * *

I welcome contibutions, if you have suggestions or would like to make improvements please submit an issue or pull request.

## Citation

Finding a “Kneedle” in a Haystack:
Detecting Knee Points in System Behavior
Ville Satopa
†
, Jeannie Albrecht†
, David Irwin‡
, and Barath Raghavan§
†Williams College, Williamstown, MA
‡University of Massachusetts Amherst, Amherst, MA
§
International Computer Science Institute, Berkeley, CA

repository: big-o/kneed

repo_name: big-o/kneed


text:
# exojax
 [![License](https://img.shields.io/github/license/HajimeKawahara/exojax)](https://github.com/HajimeKawahara/exojax/blob/develop/LICENSE)
 [![Docs](https://img.shields.io/badge/docs-exojax-brightgreen)](http://secondearths.sakura.ne.jp/exojax/)
 [![arxiv](https://img.shields.io/badge/arxiv-2105.14782-blue)](http://arxiv.org/abs/2105.14782)

Auto-differentiable line-by-line spectral modeling of exoplanets/brown dwarfs using JAX. Read [the docs](http://secondearths.sakura.ne.jp/exojax) 🐕.

## Functions

Voigt Profile :heavy_check_mark:

```python3
from exojax.spec import voigt
nu=numpy.linspace(-10,10,100)
voigt(nu,1.0,2.0) #sigma_D=1.0, gamma_L=2.0
```

Cross Section using HITRAN/HITEMP/ExoMol :heavy_check_mark:

```python
from exojax.spec import AutoXS
nus=numpy.linspace(1900.0,2300.0,40000,dtype=numpy.float64) #wavenumber (cm-1)
autoxs=AutoXS(nus,"ExoMol","CO") #using ExoMol CO (12C-16O). HITRAN and HITEMP are also supported.
xsv=autoxs.xsection(1000.0,1.0) #cross section for 1000K, 1bar (cm2)
```

 Do you just want to plot the line strength?

```python
ls=autoxs.linest(1000.0,1.0) #line strength for 1000K, 1bar (cm)
plt.plot(autoxs.mdb.nu_lines,ls,".")
```

autoxs.mdb is the [moldb.MdbExomol class](http://secondearths.sakura.ne.jp/exojax/exojax/exojax.spec.html#exojax.spec.moldb.MdbExomol) for molecular database. Here is a entrance to a deeper level. exojax is more flexible in the way it calculates the molecular lines. 🐈 Go to [the docs](http://secondearths.sakura.ne.jp/exojax) for the deeper level.

Emission Spectrum :heavy_check_mark:

```python
from exojax.spec.rtransfer import nugrid
from exojax.spec import AutoRT
nus,wav,res=nugrid(1900.0,2300.0,40000,"cm-1")
Parr=numpy.logspace(-8,2,100) #100 layers from 10^-8 bar to 10^2 bar
Tarr = 500.*(Parr/Parr[-1])**0.02
autort=AutoRT(nus,1.e5,2.33,Tarr,Parr) #g=1.e5 cm/s2, mmw=2.33
autort.addcia("H2-H2",0.74,0.74)       #CIA, mmr(H)=0.74
autort.addcia("H2-He",0.74,0.25)       #CIA, mmr(He)=0.25
autort.addmol("ExoMol","CO",0.01)      #CO line, mmr(CO)=0.01
F=autort.rtrun()
```

Are you an observer?

```python
nusobs=numpy.linspace(1900.0,2300.0,10000,dtype=numpy.float64) #observation wavenumber bin (cm-1)
F=autort.spectrum(nusobs,100000.0,20.0,0.0) #R=100000, vsini=10km/s, RV=0km/s
```

If you want to customize the model, see [here](http://secondearths.sakura.ne.jp/exojax/tutorials/forward_modeling.html).

HMC-NUTS of Emission Spectra :heavy_check_mark:

To fit a spectrum model to real data, you need to know a little more about exojax. See [here](http://secondearths.sakura.ne.jp/exojax/tutorials/reverse_modeling.html).

🥥 HMC-NUTS modeling of a brown dwarf, [Luhman 16 A](https://en.wikipedia.org/wiki/Luhman_16) using exojax.  See [here](http://secondearths.sakura.ne.jp/exojax/tutorials/fitbd.html) for an example of the Bayes inference using the real spectrum.

HMC-NUTS of Transmission Spectra :x: Not supported yet.

Cloud modeling :x:  Not supported yet.

## Installation

```
pip install exojax
```

or

```
python setup.py install
```

 Note on installation w/ GPU support

:books: You need to install CUDA, NumPyro, JAX w/ NVIDIA GPU support, and cuDNN.

- NumPyro

exojax supports NumPyro >0.5.0, which enables [the forward differentiation of HMC-NUTS](http://num.pyro.ai/en/latest/mcmc.html#numpyro.infer.hmc.NUTS). Please check the required JAX version by NumPyro. In May 2021, it seems the recent version of [NumPyro](https://github.com/pyro-ppl/numpyro) requires jaxlib>=0.1.62 (see [setup.py](https://github.com/pyro-ppl/numpyro/blob/master/setup.py) of NumPyro for instance).

- JAX

Check you cuda version:

```
nvcc -V
```

Install such as

```
pip install --upgrade jax jaxlib==0.1.62+cuda112  -f https://storage.googleapis.com/jax-releases/jax_releases.html
```

In this case, jaxlib version is 0.1.62 and cuda version is 11.2. You can check which cuda version is avaiable at [here](https://storage.googleapis.com/jax-releases/jax_releases.html)

Visit [here](https://github.com/google/jax) for the details.

- cuDNN

For instance, get .deb from NVIDIA and install such as

```
sudo dpkg -i libcudnn8_<IP_ADDRESS>-1+cuda11.3_amd64.deb
```

cuDNN is used for to compute the astronomical/instrumental response for the large number of wave number grid (exojax.spec.response). Otherwise, we do not use it.

## References

- Kawahara, Kawashima, Masuda, and Crossfield (2021) under review: [arXiv:2105.14782](http://arxiv.org/abs/2105.14782)

## License

🐈 Copyright 2020-2021 [Hajime Kawahara](http://secondearths.sakura.ne.jp/en/index.html). exojax is publicly available under the MIT license. Under development since Dec. 2020.


text:
---
published: true
layout: post
title: "Updating to ElasticStack 5.0"
author: Karim Elatov
categories: [security,os]
tags: [elasticstack,elk,kibana,elasticsearch,logstash]
---
### Updating Logstash, ElasticSearch, and Kibana to 5.0

I had the following versions installed of the ELK (**elasticsearch**,**logstash**,**kibana**) Stack:

	<> rpm -qa | grep -iE 'kibana|elastic|logst'
	logstash-2.3.4-1.noarch
	elasticsearch-2.4.1-1.noarch
	kibana-4.5.4-1.x86_64

I read over the [Upgrading the Elastic Stack](https://www.elastic.co/guide/en/elastic-stack/current/upgrading-elastic-stack.html), and here is the recommended update order:

> 1. Elasticsearch Hadoop (can talk to Elasticsearch 5.0 and 2.x)
> 2. Elasticsearch
> 	* X-Pack for Elasticsearch (combines Marvel Agent, Shield, Watcher, and Graph)
> 3. Kibana (now includes Timelion and Console, formerly known as Sense)
> 	* X-Pack for Kibana (combines Marvel, Shield, Graph, and Reporting)
> 4. Logstash
> 5. Beats

Let's try it out.

### Updating ElasticSearch from 2.4 to 5.0

Reading over [Upgrading Elasticsearch](https://www.elastic.co/guide/en/elasticsearch/reference/5.0/setup-upgrade.html) there is a table of suggested updates.

![es-update-table](https://raw.githubusercontent.com/elatov/upload/master/update-es-50/es-update-table.png)

I think the biggest concern is whether you need to reindex old indices. I was on **elasticsearch** 2.4 and I was using **logstash**'s time based indices so I didn't need to worry about that (I also used [curator](https://www.elastic.co/guide/en/elasticsearch/client/curator/current/examples.html) to delete old indices):

	<> curl 'localhost:9200/_cat/indices?v'
	health status index               pri rep docs.count docs.deleted store.size pri.store.size
	yellow open   logstash-2016.10.22   5   1     172206            0     66.1mb         66.1mb
	yellow open   logstash-2016.10.23   5   1     237647            0     86.8mb         86.8mb
	yellow open   logstash-2016.10.24   5   1    1834855            0
       62.7mb         62.7mb
    ...
	yellow open   .kibana               1   1         46            1       63kb           63kb
	yellow open   logstash-2016.10.05   5   1     135822            0     58.4mb         58.4mb

So I didn't worry about the **re-index and update** approach. I then stopped **logstash** and **kibana** in preparation for the update:

	<> sudo systemctl stop logstash.service
	<> sudo systemctl stop kibana

After that I went to the [Full cluster restart upgrade](https://www.elastic.co/guide/en/elasticsearch/reference/5.0/restart-upgrade.html) page and started the update. First **disable shard allocation**:

	<> curl -XPUT 'localhost:9200/_cluster/settings?pretty' -d'
	 > {
	 >   "persistent": {
	 >     "cluster.routing.allocation.enable": "none"
	 >   }
	 > }'
	{
	  "acknowledged" : true,
	  "persistent" : {
	    "cluster" : {
	      "routing" : {
	        "allocation" : {
	          "enable" : "none"
	        }
	      }
	    }
	  },
	  "transient" : { }
	}

Next **perform a synced flush**:

	<> curl -XPOST 'localhost:9200/_flush/synced?pretty'
	{
	  "_shards" : {
	    "total" : 552,
	    "successful" : 276,
	    "failed" : 0
	  },
	  "logstash-2016.10.22" : {
	    "total" : 10,
	    "successful" : 5,
	    "failed" : 0
	  },
	  "logstash-2016.10.23" : {
	    "total" : 10,
	    "successful" : 5,
	    "failed" : 0
	  },
		...
	  },
	  ".kibana" : {
	    "total" : 2,
	    "successful" : 1,
	    "failed" : 0
	  },
	}

Now let's shutdown the node.

	<> sudo systemctl stop elasticsearch.service

And then we can check out the [Install Elasticsearch with RPM](https://www.elastic.co/guide/en/elasticsearch/reference/5.0/rpm.html) page. We just
need to update our repo file to look like this:

	<> cat /etc/yum.repos.d/es.repo
	[elasticsearch-5.x]
	name=Elasticsearch repository for 5.x packages
	baseurl=https://artifacts.elastic.co/packages/5.x/yum
	gpgcheck=1
	gpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch
	enabled=1
	autorefresh=1
	type=rpm-md

and import the GPG key:

	<> sudo rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch

And now for the update:

	<> sudo yum update elasticsearch
	Loaded plugins: fastestmirror, remove-with-leaves
	Loading mirror speeds from cached hostfile
	 * atomic: www3.atomicorp.com
	 * base: denver.gaminghost.co
	 * epel: muug.ca
	 * extras: mirrors.unifiedlayer.com
	 * updates: mirrors.ocf.berkeley.edu
	Resolving Dependencies
	--> Running transaction check
	---> Package elasticsearch.noarch 0:2.4.1-1 will be updated
	---> Package elasticsearch.noarch 0:5.0.0-1 will be an update
		Total download size: 31 M
		...
	Is this ok [y/d/N]: y
	Downloading packages:
	No Presto metadata available for elasticsearch-5.x
	elasticsearch-5.0.0.rpm                                                                                |  31 MB  00:00:02
	Running transaction check
	Running transaction test
	Transaction test succeeded
	Running transaction
	  Updating   : elasticsearch-5.0.0-1.noarch                                                                                1/2
	  Cleanup    : elasticsearch-2.4.1-1.noarch                                                                                2/2
	warning: /etc/elasticsearch/logging.yml saved as /etc/elasticsearch/logging.yml.rpmsave
	  Verifying  : elasticsearch-5.0.0-1.noarch                                                                                1/2
	  Verifying  : elasticsearch-2.4.1-1.noarch                                                                                2/2

	Updated:
	  elasticsearch.noarch 0:5.0.0-1

	Complete!

I didn't have any plugins so at this point I just started the service back up:

	<> sudo systemctl daemon-reload
	<> sudo systemctl start elasticsearch.service
	<> sudo journalctl -fu elasticsearch.service
	-- Logs begin at Wed 2016-10-26 07:23:03 MDT. --
	Oct 29 10:33:00 puppet.kar.int elasticsearch[944]: at java.lang.Thread.run(Thread.java:745)
	Oct 29 14:26:09 puppet.kar.int elasticsearch[944]: [2016-10-29 14:26:09,954][INFO ][cluster.routing.allocation.decider] [Fashima] updating [cluster.routing.allocation.enable] from [ALL] to [NONE]
	Oct 29 14:29:18 puppet.kar.int systemd[1]: Stopping Elasticsearch...
	Oct 29 14:29:18 puppet.kar.int elasticsearch[944]: [2016-10-29 14:29:18,199][INFO ][node                     ] [Fashima] stopping ...
	Oct 29 14:29:18 puppet.kar.int elasticsearch[944]: [2016-10-29 14:29:18,502][INFO ][node                     ] [Fashima] stopped
	Oct 29 14:29:18 puppet.kar.int elasticsearch[944]: [2016-10-29 14:29:18,502][INFO ][node                     ] [Fashima] closing ...
	Oct 29 14:29:18 puppet.kar.int elasticsearch[944]: [2016-10-29 14:29:18,512][INFO ][node                     ] [Fashima] closed
	Oct 29 14:29:18 puppet.kar.int systemd[1]: Stopped Elasticsearch.
	Oct 29 14:35:00 puppet.kar.int systemd[1]: Starting Elasticsearch...
	Oct 29 14:35:00 puppet.kar.int systemd[1]: Started Elasticsearch.

Then we can check out the status:

	<> curl -XGET 'localhost:9200/_cat/health?pretty'
<PHONE_NUMBER> 14:37:08 elasticsearch yellow 1 1 276 276 0 0 276 0 - 50.0%

	<> curl -XGET 'localhost:9200/_cat/nodes?pretty'
	<IP_ADDRESS> 23 97 19 0.48 0.38 0.28 mdi * NVsq0kL

and then we can confirm the indices are okay as well:

	<> curl 'localhost:9200/_cat/indices?v'
	health status index               uuid                   pri rep docs.count docs.deleted store.size pri.store.size
	yellow open   logstash-2016.09.28 U19hImjjTImCAOzT5RSYHw   5   1     140980            0     64.9mb         64.9mb
	...
	yellow open   .kibana             m4qTcJx4TKi9zxZaWufOoA   1   1         46            1       63kb           63kb
	...
	yellow open   logstash-2016.09.30 9Ayf0BgRS6mvVtoW_f_oNw   5   1     143003            0       67mb           67mb

Now let's renabled allocation:

	<> curl -XPUT 'localhost:9200/_cluster/settings?pretty' -d'
	 > {
	 >   "persistent": {
	 >     "cluster.routing.allocation.enable": "all"
	 >   }
	 > }'
	{
	  "acknowledged" : true,
	  "persistent" : {
	    "cluster" : {
	      "routing" : {
	        "allocation" : {
	          "enable" : "all"
	        }
	      }
	    }
	  },
	  "transient" : { }
	}

You can also confirm the version of **elasticsearch**:

	<> curl -XGET 'localhost:9200'
	{
	  "name" : "NVsq0kL",
	  "cluster_name" : "elasticsearch",
	  "cluster_uuid" : "E4lDuM2KRH-Mi11k_7jiKQ",
	  "version" : {
	    "number" : "5.0.0",
	    "build_hash" : "253032b",
	    "build_date" : "2016-10-26T04:37:51.531Z",
	    "build_snapshot" : false,
	    "lucene_version" : "6.2.0"
	  },
	  "tagline" : "You Know, for Search"
	}

### Updating Kibana from 4.5 to 5.0

I read over [Upgrading Kibana](https://www.elastic.co/guide/en/kibana/5.0/upgrade.html) and checking out the table, I can just do a **standard** upgrade without doing a re-index (since I was using **logstash**'s time based indices):

![kib-update-table](https://raw.githubusercontent.com/elatov/upload/master/update-es-50/kib-update-table.png)

I started using Kibana from 4.3 and above (you can check out the original setup that I did [here](/2016/02/playing-around-with-an-elasticsearchlogstashkibana-elk-stack/)) so I was good. The steps for the update are layed out
in the [Standard Upgrade](https://www.elastic.co/guide/en/kibana/5.0/upgrade-standard.html) page. First you stop the **kibana** instance, which I did above. Then install the rpm, since **elasticsearch** and **kibana** share the repo, I didn't have to do anything special.  Then I performed the update:

	<> sudo yum update kibana
	[sudo] password for elatov:
	Loaded plugins: fastestmirror, remove-with-leaves
	Loading mirror speeds from cached hostfile
	 * atomic: www3.atomicorp.com
	 * base: denver.gaminghost.co
	 * epel: muug.ca
	 * extras: mirrors.unifiedlayer.com
	 * updates: mirrors.ocf.berkeley.edu
	Resolving Dependencies
	--> Running transaction check
	---> Package kibana.x86_64 0:4.5.4-1 will be updated
	---> Package kibana.x86_64 0:5.0.0-1 will be an update
	--> Finished Dependency Resolution

		Upgrade  1 Package

	Total download size: 39 M
	Is this ok [y/d/N]: y
	Downloading packages:
	No Presto metadata available for elasticsearch-5.x
	kibana-5.0.0-x86_64.rpm                                                                                |  39 MB  00:00:04
	Running transaction check
	Running transaction test
	Transaction test succeeded
	Running transaction
	  Updating   : kibana-5.0.0-1.x86_64                                                                                1/2
	Stopping kibana service... OK
	  Cleanup    : kibana-4.5.4-1.x86_64                                                                                2/2
	warning: /opt/kibana/config/kibana.yml saved as /opt/kibana/config/kibana.yml.rpmsave
	  Verifying  : kibana-5.0.0-1.x86_64                                                                                1/2
	  Verifying  : kibana-4.5.4-1.x86_64                                                                                2/2

	Updated:
	  kibana.x86_64 0:5.0.0-1

	Complete!

Then I went ahead and copied the config over:

	<> sudo cp /etc/kibana/kibana.yml /etc/kibana/kibana.yml.orig
	<> sudo cp /opt/kibana/config/kibana.yml.rpmsave /etc/kibana/kibana.yml

I didn't have any plugins for **kibana** so I just started up the service:

	<> sudo systemctl daemon-reload
	<> sudo systemctl start kibana.service
	<> sudo journalctl -fu kibana
	-- Logs begin at Wed 2016-10-26 07:23:03 MDT. --
	Oct 29 14:25:21 puppet.kar.int systemd[1]: Stopped no description given.
	Oct 29 14:53:59 puppet.kar.int systemd[1]: Started Kibana.
	Oct 29 14:53:59 puppet.kar.int systemd[1]: Starting Kibana...
	Oct 29 14:54:02 puppet.kar.int kibana[30328]: {"type":"log","@timestamp":"2016-10-29T20:54:02Z","tags":["status","plugin:kibana@5.0.0","info"],"pid":30328,"state":"green","message":"Status changed from uninitialized to green - Ready","prevState":"uninitialized","prevMsg":"uninitialized"}
	Oct 29 14:54:02 puppet.kar.int kibana[30328]: {"type":"log","@timestamp":"2016-10-29T20:54:02Z","tags":["status","plugin:elasticsearch@5.0.0","info"],"pid":30328,"state":"yellow","message":"Status changed from uninitialized to yellow - Waiting for Elasticsearch","prevState":"uninitialized","prevMsg":"uninitialized"}
	Oct 29 14:54:02 puppet.kar.int kibana[30328]: {"type":"log","@timestamp":"2016-10-29T20:54:02Z","tags":["status","plugin:console@5.0.0","info"],"pid":30328,"state":"green","message":"Status changed from uninitialized to green - Ready","prevState":"uninitialized","prevMsg":"uninitialized"}
	Oct 29 14:54:03 puppet.kar.int kibana[30328]: {"type":"log","@timestamp":"2016-10-29T20:54:03Z","tags":["status","plugin:timelion@5.0.0","info"],"pid":30328,"state":"green","message":"Status changed from uninitialized to green - Ready","prevState":"uninitialized","prevMsg":"uninitialized"}
	Oct 29 14:54:03 puppet.kar.int kibana[30328]: {"type":"log","@timestamp":"2016-10-29T20:54:03Z","tags":["status","plugin:elasticsearch@5.0.0","info"],"pid":30328,"state":"green","message":"Status changed from yellow to green - Kibana index ready","prevState":"yellow","prevMsg":"Waiting for Elasticsearch"}
	Oct 29 14:54:03 puppet.kar.int kibana[30328]: {"type":"log","@timestamp":"2016-10-29T20:54:03Z","tags":["listening","info"],"pid":30328,"message":"Server running at http://<IP_ADDRESS>:5601"}
	Oct 29 14:54:03 puppet.kar.int kibana[30328]: {"type":"log","@timestamp":"2016-10-29T20:54:03Z","tags":["status","ui settings","info"],"pid":30328,"state":"green","message":"Status changed from uninitialized to green - Ready","prevState":"uninitialized","prevMsg":"uninitialized"}

Then you can point your browser to the **kibana** dashboard and see the new
version:

![kib-50](https://raw.githubusercontent.com/elatov/upload/master/update-es-50/kib-50.png)

### Updating Logstash from 2.3 to 5.0

I read over [Upgrading Logstash to 5.0](https://www.elastic.co/guide/en/logstash/5.0/upgrading-logstash.html) and I didn't see anything bad about the update. Then I followed the instructions laid out in [Upgrading Using Package Managers](https://www.elastic.co/guide/en/logstash/current/upgrading-using-package-managers.html) to do the update. First stop **logstash**, which I did above. Then add the repo, which I did during the **elasticsearch** update. And then I updated the package:

	<> sudo yum update
	Loaded plugins: fastestmirror, remove-with-leaves
	Loading mirror speeds from cached hostfile
	 * atomic: www3.atomicorp.com
	 * base: denver.gaminghost.co
	 * epel: muug.ca
	 * extras: mirrors.unifiedlayer.com
	 * updates: mirrors.ocf.berkeley.edu
	Resolving Dependencies
	--> Running transaction check
	---> Package logstash.noarch 1:2.3.4-1 will be updated
	---> Package logstash.noarch 1:5.0.0-1 will be an update
	--> Finished Dependency Resolution

		Upgrade  1 Package

	Total download size: 101 M
	Is this ok [y/d/N]: y
	Downloading packages:
	No Presto metadata available for elasticsearch-5.x
	logstash-5.0.0.rpm                                                                                | 101 MB  00:00:12
	Running transaction check
	Running transaction test
	Transaction test succeeded
	Running transaction
	  Updating   : 1:logstash-5.0.0-1.noarch                                                                                1/2
	Using provided startup.options file: /etc/logstash/startup.options
	Successfully created system startup script for Logstash
	  Cleanup    : 1:logstash-2.3.4-1.noarch                                                                                2/2
	warning: /etc/logrotate.d/logstash saved as /etc/logrotate.d/logstash.rpmsave
	  Verifying  : 1:logstash-5.0.0-1.noarch                                                                                1/2
	  Verifying  : 1:logstash-2.3.4-1.noarch                                                                                2/2

	Updated:
	  logstash.noarch 1:5.0.0-1

	Complete!

Then I confirmed the config file is okay:

	<> sudo /usr/share/logstash/bin/logstash --config.test_and_exit --path.settings=/etc/logstash/ -f /etc/logstash/conf.d/logstash-syslog.conf
	Sending Logstash logs to /var/log/logstash which is now configured via log4j2.properties.
	Configuration OK

Now let's start the service:

	<> sudo systemctl daemon-reload
	<> sudo systemctl start logstash.service
	<> sudo journalctl -fu logstash.service
	-- Logs begin at Wed 2016-10-26 07:23:03 MDT. --
	Oct 29 15:27:28 puppet.kar.int logstash[32100]: "type" => "syslog",
	Oct 29 15:27:28 puppet.kar.int logstash[32100]: "syslog_message" => "Popping table",
	Oct 29 15:27:28 puppet.kar.int logstash[32100]: "syslog_pri" => "15",
	Oct 29 15:27:28 puppet.kar.int logstash[32100]: "tags" => [
	Oct 29 15:27:28 puppet.kar.int logstash[32100]: [0] "_geoip_lookup_failure"
	Oct 29 15:27:28 puppet.kar.int logstash[32100]: ]
	Oct 29 15:27:28 puppet.kar.int logstash[32100]: }
	Oct 29 15:27:29 puppet.kar.int systemd[1]: Stopping logstash...
	Oct 29 15:27:36 puppet.kar.int systemd[1]: Started logstash.
	Oct 29 15:27:36 puppet.kar.int systemd[1]: Starting logstash...
	Oct 29 15:27:50 puppet.kar.int logstash[551]: Sending Logstash logs to /var/log/logstash which is now configured via log4j2.properties.
	Oct 29 15:27:54 puppet.kar.int logstash[551]: {
	Oct 29 15:27:54 puppet.kar.int logstash[551]: "reason" => "match",
	Oct 29 15:27:54 puppet.kar.int logstash[551]: "flags" => "DF",
	Oct 29 15:27:54 puppet.kar.int logstash[551]: "rule" => "5",
	Oct 29 15:27:54 puppet.kar.int logstash[551]: "type" => "pfsense",

I used to use the **stdout** output module, but with 5.0 that ended up logging to **syslog** and **journalctl**, so I changed that to be **file** instead of **stdout**:

	<> tail -3 /etc/logstash/conf.d/logstash-syslog.conf
	  file { path => "/var/log/logstash/logstash-syslog.log" codec => rubydebug }
	#  stdout { codec => rubydebug }
	}

Then one more restart:

	<> sudo systemctl restart logstash

and I saw the logs under **/var/log/logstash/logstash-syslog.log** and not under **/var/log/messages**. I had to re-add the **logrotate** config back since the rpm install removed it. Also with the new version there is an API now available on **logstash**, so you could check out the version like this:

	<> curl "<IP_ADDRESS>:9600/?pretty"
	{
	  "host" : "puppet.kar.int",
	  "version" : "5.0.0",
	  "http_address" : "<IP_ADDRESS>:9600",
	  "build_date" : "2016-10-26T04:09:44Z",
	  "build_sha" : "6ffe6451db6a0157cc6dd23458a0342c3118a9b0",
	  "build_snapshot" : false
	}%

### Post Upgrade Changes
I ended up lowering the memory usage for the **logstash** and **elasticsearch** java instances:

	<> grep -iE '^\-Xms|^\-Xmx' /etc/logstash/jvm.options /etc/elasticsearch/jvm.options
	/etc/logstash/jvm.options:-Xms256m
	/etc/logstash/jvm.options:-Xmx512m
	/etc/elasticsearch/jvm.options:-Xms768m
	/etc/elasticsearch/jvm.options:-Xmx768m

Also my **logstash** config kept failing to do geoip lookup on internal IPs. I had the setup that's covered [here](http://elatov.github.io/2016/04/suricata-logs-in-splunk-and-elk/) which didn't do geoip lookups on internal IPs. I had to move the *src_ip* **if** loop inside the first if statement that checked if it's a **SuricataIDPS** type. After that the geoip started working appropriately. I feels like the **filter** option is now globally applied to all the inputs not just within the config file.


text:
ArduiCopter
===========

Arduino Quad Copter Controller

  - Using Arduino to control QuadCopter
  - Controller written by Java
  - GUI design by JavaFX

How to develop
--------------
**For the software you need :**
 1. Arduino IDE
 2. NetBeans IDE
 3. JDK 1.8

**For Arduino, I use these libraries :**
 1. [ADXL345.h][1]
 2. [L3G.h][2]
 3. [Adafruit_BMP085.h][3]

**Hardware :**
 1. Arduino UNO (ATMega 238p)
 2. Expansion board for UNO (optional)
 3. A QuadCopter with PWM motor controller

License
----
MIT

  [1]: https://github.com/jenschr/Arduino-libraries/tree/master/ADXL345
  [2]: https://github.com/pololu/l3g-arduino
  [3]: https://github.com/adafruit/Adafruit-BMP085-Library


text:
---
layout: post
title: "OsCYP84A"
description: ""
category: genes
tags: [growth]
---

* **Information**
    + Symbol: OsCYP84A
    + MSU: [LOC_Os10g17260](http://rice.uga.edu/cgi-bin/ORF_infopage.cgi?orf=LOC_Os10g17260)
    + RAPdb: [Os10g0320100](https://rapdb.dna.affrc.go.jp/locus/?name=Os10g0320100)

* **Publication**
    + [A Rice Cytochrome P450OsCYP84AThat May Interact with the UV Tolerance Pathway](http://www.ncbi.nlm.nih.gov/pubmed?term=A Rice Cytochrome P450OsCYP84AThat May Interact with the UV Tolerance Pathway%5BTitle%5D), 2014, Bioscience, Biotechnology and Biochemistry.

* **Genbank accession number**

* **Key message**
    + Rice transformants in which OsCYP84A expression was suppressed by the antisense gene showed apparent growth retardation with obvious symptoms of damage on the plant bodies under UV-B irradiation, although no phenotypic alteration occurred under normal growth conditions

* **Connection**

[//]: # * **Key figures**


text:
Time capsule setup
==================

run `./setup.sh` to mount and setup disk attached to raspberry pi as a time capsule devise to be used with Mac's Time Machine

![attaching rpi drive](https://user-images.githubusercontent.com/2007057/30040517-03d27a5e-9195-11e7-8e64-d262cce58e56.png)

repository: antontsv/pi-timecapsule

repo_name: antontsv/pi-timecapsule


text:
# scBSC 0.1.0

* Initial build

# scBSC 0.1.1

* Added a `NEWS.md` file to track changes to the package.

# scBSC 0.1.2

* Fixed examples to refer to github page and readme to include more figures.

# scBSC 0.1.3

* Added class slot and list validations.

repository: soymintc/scBSC

repo_name: soymintc/scBSC


text:
# scmeta

This tool sit's on top of the hyperfine results and combines them with other meta data about the language like the version and name.

Files needed as input:
- hyperfine.json
- pi.txt

## Contributors

- [Niklas Heer](https://github.com/your-github-user) - creator and maintainer

repository: niklas-heer/speed-comparison

gha_language: Earthly

repo_name: niklas-heer/speed-comparison


text:
# Factorio statistics tool

This will be a factorio statistics logger + viewer to analyze resource
consumption and buffer levels.

## Usage:

For now, find the `scripts_output` directory in the factorio installation
directory and run `tail -f script-output/outfile | nc <host> <port>`

Note that no output will be written unless you actually have some chests with
items in them.

repository: Windfisch/factorio-statistics

repo_name: Windfisch/factorio-statistics


text:
### Addresses #<!--issue number here-->

### Pull Request Description

<!--description here]-->

### Checklist
<!--Delete lines that don't apply-->

- [ ] Documentation has been modified appropriately
- [ ] An ISSUE has been created that this is addressing. Issues will get added to the Change Log when the change_log.rb script is run
- [ ] This branch is up-to-date with develop

branch_name: refs/heads/develop

gha_language: HTML

gha_license_id: NOASSERTION


text:
### Commit/Merge messages
Commit messages should be in the following format:
> `type(category): [description] [issue number].`

Must be one of the following **types**:
- `a11y`
- `chore`
- `docs`
- `feat`
- `fix`
- `other`
- `refactor`
- `style`
- `test`

**Category:** This should be an area or feature name. For example, c-button.

**Description:** A single line, lowercase, ending with a '.', and without naming any component this relates to. Components can be referred to by the *Tag(s)*.

**Issue number:** Maps directly to the GitHub issue number. Can be more than one if the work is related.

**Labels:** Specific changes mapping to how work is managed across the project.

Example:
>`docs(readme): add an accessibility section to the readme [123456]`

repository: oguduvictor/fast-animation

repo_name: oguduvictor/fast-animation


text:
# Fhir Immunizations Demo

The goal of the application is to demostrate how to interact with a FHIR data
store from a Javascript application. The application itself allows users
to track the immunizations they have received and which ones may be coming up
for renewal. The application also provides immunization suggestions for
countries that the user indicates they will be travelling to.

# Development

The application is developed using the Angular CLI. More information about
that project can be found on their [website](https://cli.angular.io/).

Install the dependencies with npm by running `npm install`. Next, follow the
Cloud Healthcare
[quickstart](https://cloud.google.com/healthcare/docs/quickstart) to set up
your project. You will also need to setup OAuth for your project, following the
instructions [here](https://cloud.google.com/docs/authentication/end-user). Finally,
create a new file at `src/environments/environment.dev.ts` with the
configuration for your new project, replacing all the `TODO_`s with their
appropriate values.

```javascript
export const environment = {
  production: false,
  clientId: TODO_OAUTH_CLIENT_ID,
  fhirEndpoint: {
    baseURL: "https://healthcare.googleapis.com/v1beta1/",
    project: TODO_PROJECT,
    location: TODO_REGION,
    dataset: TODO_DATASET,
    fhirStore: TODO_FHIR_STORE
  }
};
```

The application can now be run with `ng serve`.

repository: GoogleCloudPlatform/healthcare

gha_language: Jupyter Notebook

repo_name: GoogleCloudPlatform/healthcare


text:
The time for spending every free minute outside to enjoy the sun and those seemingly endless summer days, be it in a nearby park, by a lake, or on a road trip, exploring unfamiliar places. So why not bring a bit of that summer joy to your desktop, too?

In this post, you’ll find free wallpapers for July 2018 created by artists and designers from across the globe as it has been . Please note that some of the wallpapers come in two versions as usual (with and without a calendar for the month), while the best-of selection at the end of the post only covers the non-calendar versions. Have a great July — no matter what you have planned!

Please note that:

All images can be clicked on and lead to the preview of the wallpaper,

You can  by taking part in our Desktop Wallpaper Calendar series. We are regularly looking for creative designers and artists to be featured on Smashing Magazine. Are you one of them?

Design Your Own Wallpaper

Igor Izhik has designed quite a lot of wallpapers for our monthly challenge. If you would like to get started yourself, check out his article in which he shares how he approaches all stages of the process as well as useful tips and tricks for creating illustrations in Adobe Illustrator.

Meet .

          <button class="btn btn--green btn--large">
            Table of Contents →
          </button>

Heated Mountains

“Warm summer weather inspired the color palette.” — Designed by  from Croatia.

with calendar:

without calendar:

Triumphant July

“This summer started out hot, with eyes wide open and monitoring the World Cup in Russia. We wanted to decorate your desktop this July with this colorful Red Square illustration, just before the eagerly anticipated finale, hoping to see the trophy awarded to our players.” — Designed by  from Serbia.

with calendar:

without calendar:

Robinson Cat

Designed by  from Sweden.

with calendar:

without calendar:

All You Need Is Ice Cream

“July is National Ice Cream Month! National Ice Cream Day is celebrated on the 3rd Sunday in July. On this day people celebrate with a bowl, cup or cone filled with their favorite flavor of ice cream. Share some ice cream and some love this month with my wallpaper!” — Designed by  from Belgium.

with calendar:

without calendar:

A Mighty Woman With A Torch

“Last year we visited NYC for the first time during the 4th of July. I took many photos of Lady Liberty and was so deeply inspired by her message.” — Designed by  from Indiana.

with calendar:

without calendar:

Night Sky Magic

Designed by  from Sweden.

with calendar:

without calendar:

Fly Forever

“Challenges are a part of parcel of life. Surpassing each challenge would be difficult, but it is you who decide whether to keep going or shun the drive. No matter whatever circumstance you are in, ignite your mind and just fly forward into action to achieve what you are capable of and what is beyond your reach.” — Designed by  from London.

with calendar:

without calendar:

Smile, It’s Summer

“July brings me to summer, and last year in summer, I went to Salzburg, Austria where I took this photo. So every beginning of summer, I think about Salzburg and how sunny and warm it was there.” — Designed by  from The Netherlands.

with calendar:

without calendar:

Even Miracles Take A Little Time

“‘One day, the people that didn't believe in you will tell everyone how they met you.’ Believe in Yourself. Give it all that you can, take your own sweet time and be your own miracle!” — Designed by  from India.

with calendar:

without calendar:

July Favorites

Lots of beautiful wallpapers have been created in the nine years since we embarked on our wallpapers adventure. And since it’d be a pity to let them gather dust, we once again dived deep into our archives on the lookout for some July treasures. Please note that these wallpapers, thus, don’t come with a calendar.

A Flamboyance Of Flamingos

“July in South Africa is dreary and wintery so we give all the southern hemisphere dwellers a bit of colour for those grey days. And for the northern hemisphere dwellers a bit of pop for their summer! The Flamboyance of Flamingos is part of our ‘Wonderland Collective Noun’ collection. Each month a new fabulous collective noun is illustrated, printed and made into a desktop wallpaper.” — Designed by  from South Africa.

without calendar:

Summer Essentials

“A few essential items for the summertime weather at the beach, park, and everywhere in-between.” — Designed by  from the USA.

without calendar:

Summer Cannonball

“Summer is coming in the northern hemisphere and what better way to enjoy it than with watermelons and cannonballs.” — Designed by  from Mexico.

without calendar:

Mason Jar

“Make the days count this summer!” — Designed by  from the USA.

without calendar:

Birdie Nam Nam

“I have created a pattern that has a summer feeling. For me July and summer is bright color, joy and lots of different flowers and birds. So naturally, I incorporated all these elements in a crazy pattern.” — Designed by  from Sweden.

without calendar:

Spectate

Designed by  from Russia.

without calendar:

Summer Never Ends!

“July is a very special month to me — it’s the month of my birthday and of the best cherries.” — Designed by  from Canada.

without calendar:

World Ufo Day

“The holiday dedicated to those who study the phenomena that have no logical explanation, and the objects, which is attributed to an extraterrestrial origin.” — Designed by Cheloveche.ru from Russia

without calendar:

Captain Amphicar

“My son and I are obsessed with the Amphicar right now, so why not have a little fun with it?” — Designed by  from the USA.

without calendar:

Tropical Lilies

“I enjoy creating tropical designs, they fuel my wanderlust and passion for the exotic. Instantaneously transporting me to a tropical destination.” — Designed by  from the USA.

without calendar:

Day Turns To Night

Designed by  from Germany.

without calendar:

Eternal Summer

“And once you let your imagination go, you find yourself surrounded by eternal summer, unexplored worlds and all-pervading warmth, where there are no rules of physics and colors tint the sky under your feet.” — Designed by  from Belgrade, Serbia.

without calendar:

Taste Like Summer!

“In times of clean eating and the world of superfoods there is one vegetable missing. An old forgotten one. A flower actually. Rare and special. Once it had a royal reputation (I cheated a bit with the blue). The artichocke — this is my superhero in the garden! I am a food lover — you too? Enjoy it — dip it!” — Designed by  from Germany.

without calendar:

Road Trip In July

“July is the middle of summer, when most of us go on road trips, so I designed a calendar inspired by my love of traveling and summer holidays.” — Designed by  from Romania.

without calendar:

World Chocolate Day

Designed by Cheloveche.ru from Russia.

without calendar:

Join In Next Month!

Please note that we respect and carefully consider the ideas and motivation behind each and every artist’s work. This is why we give all artists the full freedom to explore their creativity and express emotions and experience throughout their works. This is also why the themes of the wallpapers weren’t anyhow influenced by us, but rather designed from scratch by the artists themselves.

Thank you to all designers for their participation.  next month!

  (il)

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

repository: iv-web/ivweb-weekly

repo_name: iv-web/ivweb-weekly


text:
# Coral Projects Doc Sync

This folder contains scripts and configuration files that generate a copy of the static html files by MkDocs from the Markdown (.md) files and copies them to the AWS S3 bucket for hosting which is viewable via CloudFront (due to https requirements by HSTS).

## Automated Publishing Workflow
1. Docs are maintained and update in markdown files
2. Github service hook to iron.io which runs Docker file
3. Server generates MkDocs site folder, copying contents to AWS S3 bucket using [http://s3tools.org/s3cmd](http://s3tools.org/s3cmd)
4. AWS Cloudfront displays static files created by MkDocs

## Team Process Workflow
1. Clone git repository
2. Ensure local repository is synched to master
3. If working on significant changes, create new branch
4. Commit changes to Github
5. Solicit Coral Team members for review and feedback
6. Merge changes

## URLs
- Production [https://docs.coralproject.net](https://docs.coralproject.net)
- Staging and testing [https://testdocs.coralproject.net](https://testdocs.coralproject.net)

## Commands

- Command to delete all files from S3 bucket using [s3tools](http://s3tools.org/s3cmd)

	~~~~
	s3cmd del -r --force s3://testdocs.coralproject.net/
	~~~~
- Command to put (push) all files to S3 using [s3tools](http://s3tools.org/s3cmd)

	~~~~
	s3cmd put ./site/* -rvM --force --no-mime-magic --guess-mime-type s3://testdocs.coralproject.net/
	~~~~

- Command to sync all changed files by comparing the md5 checksum between local and S3 bucket files using [s3tools](http://s3tools.org/s3cmd)
	~~~~

	s3cmd sync ./site/* -rvM --force --no-mime-magic --guess-mime-type --check-md5 s3://testdocs.coralproject.net/
	~~~~

- Command to compress and upload docsync folder contents to Iron.io (run within the folder)

	~~~~
zip -r docsync.zip . && iron worker upload --zip docsync.zip --name docsync coralproject/docsync ./docsync.sh
	~~~~

## Automated Publishing Workflow Set Up //Needs Update//
1. Create an Iron.io account if you do not already have one.
2. Create an Iron.io Project.
3. In the project page, go to Credentials (Key icon) > Download iron.json file.
4. Place the iron.json file in this directory (/docs/docsync)
5. Install the Iron.io command line utility:
  `curl -sSL https://cli.iron.io/install | sh`
6. Copy `config.sample.sh` to `config.sh`
7. Enter the following values into config.sh:
	  - GITHUB_REPO: Github repo to copy from
	  - S3_BUCKET: S3 bucket to copy to
	  - SUBDIR: Subdirectory of repo to copy, ie /site
	  - AWS_ACCESS_KEY: AWS access key
	  - AWS_SECRET_KEY: AWS secret key
8. Upload docsync to iron.io:
 `zip -r docsync.zip . && iron worker upload --zip docsync.zip --name docsync coralproject/docsync ./docsync.sh`

repository: coralproject/ask-docs

repo_name: coralproject/ask-docs


text:
# ADS

ADS = Advanced Data Structures

## Introduction

This repository serves as a container for abstract data structures' components. These components are implemented in the C++11 programming language.

## Current Data Structure

1.  String Structures
    -   Tries & Compressed Trie

repository: BurhanOtour/ADS

repo_name: BurhanOtour/ADS


text:
Games Collection - Backend

[![Status](https://img.shields.io/badge/status-active-success.svg)]()
[![License](https://img.shields.io/badge/license-MIT-blue.svg)](/LICENSE)

---

This application implements database search queries using 3 different methods, ORM, QueryBuilder and Raw Queryes with the typeorm. Users have game lists they own, and different find methods are implemented.

This project was done using Typescript, Node, Express, Postgres and it utilizes from the SOLID principles.

---

## 📝 Table of Contents

- [Application Features](#features)
- [Dependencies](#dependencies)
- [Built Using](#built_using)
- [Getting Started](#getting_started)
- [Acknowledgements](#acknowledgements)
- [Licenses](#licenses)
- [Authors](#authors)

---

## 🧐 Application Features

With this application the client can access the following routes

1. `findUserWithGamesById` → should be able to find user with games list by user's ID.

1. `findAllUsersOrderedByFirstName` → should be able to list users ordered by first name.

1. `findUserByFullName` → should be able to find user by full name.

1. `findByTitleContaining` → should be able find a game by entire or partial given title.

1. `countAllGames` → should be able to get the total count of games.

1. `findUsersByGameId` → should be able to list users who have given game id.

---

## 🔁 Dependencies

Some project library dependencies includes but are not limited to:

- "typescript": "^4.2.3",
- "uuid": "^8.3.2"
- "jest": "^26.6.3",
- "nodemon": "^2.0.7",
- "typeorm": "^0.2.31",
- "pg": "^8.5.1",

---

## ⛏ Built Using

- [JavaScript](https://www.javascript.com/) - Programming Language
- [TypeScript](https://www.typescriptlang.org/) - Programming Language
- [Express](https://expressjs.com/) - Server Framework
- [NodeJs](https://nodejs.org/en/) - Server Environment
- [PostgreSQL](https://www.postgresql.org/) - Relational Database
- [Docker](https://www.docker.com/) - Containerization Platform

---

## 🏁 Getting Started

You can clone the repository through Command Prompt or Terminal just by typing:

```sh
git clone https://github.com/devfel/collections-backend.git
```

or download the zip from the green **"Code"** button.

Install dependencies packages with yarn

```sh
yarn
```

With the dependencies installed and the database created run yarn test.
If you are using docker the following command can be used to create an appropriated database.

```sh
docker run --name container_name -e POSTGRES_USER=user_name -e POSTGRES_PASSWORD=password -e POSTGRES_DB=database_name -p 5432:5432 -d postgres
```

Replace container_name, user_name, password and database_name with the ones you want, for this project we recommend:

- "user_name": "postgres",
- "password": "docker",
- "database_name": "queries_challenge",

---

## 🎉 Acknowledgements

- Created based on a [RocketSeat](https://rocketseat.com.br/) challenge.
- Full description in Brazilian Portuguese: [Trilha Node.js - Desafio 06](https://www.notion.so/Desafio-01-Database-Queries-8d97dae581d5446e97555c43d301ee45)

- Additional challenge, database modeling: [Trilha Node.js - Desafio 07](https://www.notion.so/Desafio-02-Modelagem-do-banco-de-dados-0ce9c10f9e114be0a9ee9359d68639ff)

---

## 📝 Liceses

- Distributed under the MIT License - see the [LICENSE.md](https://github.com/devfel/collections-backend/blob/master/LICENSE.md) file for details.

---

## ✍ Author

- [@devfel](https://devfel.com/) - Luiz Flávio Felizardo

repository: devfel/collections-backend

repo_name: devfel/collections-backend


text:
# Flask-EasyJWT

[![PyPI](https://img.shields.io/pypi/v/flask-easyjwt.svg)](https://pypi.org/project/flask-easyjwt/)
[![PyPI - License](https://img.shields.io/pypi/l/flask-easyjwt.svg)](https://github.com/BMeu/Flask-EasyJWT/blob/master/LICENSE)
[![Build Status](https://travis-ci.org/BMeu/Flask-EasyJWT.svg?branch=master)](https://travis-ci.org/BMeu/Flask-EasyJWT)
[![codecov](https://codecov.io/gh/BMeu/Flask-EasyJWT/branch/master/graph/badge.svg)](https://codecov.io/gh/BMeu/Flask-EasyJWT)
[![Documentation Status](https://readthedocs.org/projects/flask-easyjwt/badge/?version=latest)](https://flask-easyjwt.readthedocs.io/en/latest/?badge=latest)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/flask-easyjwt.svg)

Flask-EasyJWT provides a simple interface to creating and verifying
[JSON Web Tokens (JWTs)](https://tools.ietf.org/html/rfc7519) in Python. It allows you to once define the claims of the
JWT, and to then create and accept tokens with these claims without having to check if all the required data is given
or if the token actually is the one you expect.

Flask-EasyJWT is a simple wrapper around [EasyJWT](https://github.com/BMeu/EasyJWT) for easy usage in
[Flask](http://flask.pocoo.org/) applications. It provides configuration options via Flask's application configuration
for common settings of all tokens created in a web application. For detailed information on how to use
[EasyJWT](https://github.com/BMeu/EasyJWT), see [its documentation](https://easyjwt.readthedocs.org/en/latest/).

```python
from flask_easyjwt import FlaskEasyJWT
from flask import Flask

# Define the claims of your token.
class MySuperSimpleJWT(FlaskEasyJWT):

    def __init__(self, key):
        super().__init__(key)

        # Define a claim `name`.
        self.name = None

# Define the default configuration options for FlaskEasyJWT
# in the configuration of your Flask app.
app = Flask(__name__)
app.config.from_mapping(
    # The default key for encoding and decoding tokens.
    EASYJWT_KEY='Super secret key',

    # Tokens will be valid for 15 minutes after creation by default.
    EASYJWT_TOKEN_VALIDITY=15 * 60
)

@app.route('/token/<name>')
def get_token(name):
    """ This view returns a token with the given name as its value. """
    token_object = MySuperSimpleJWT()
    token_object.name = name
    return token_object.create()

@app.route('/verify/<token>')
def verify_token(token):
    """ This view verifies the given token and returns the contained name. """
    verified_token_object = MySuperSimpleJWT.verify(token)
    return verified_token_object.name
```

## Features

 * Integrates [EasyJWT](https://github.com/BMeu/EasyJWT) into Flask for easy configuration of default options for
   creating and verifying JWTs.
 * Define the claims of your token once as a class, then use this class to easily create and verify multiple tokens.
 * No worries about typos in dictionary keys: the definition of your claim set as a class enables IDEs to find those
   typos for you.
 * Multiple tokens may have the same claims, but different intentions. Flask-EasyJWT will take care of this for you: you
   can define a token for account validation and one for account deletion, both with the account ID as a claim, and you
   don't need to worry about accidentally deleting a newly created account instead of validating it, just because
   someone mixed up the tokens.
 * All registered JWT claims are supported: `aud`, `exp`, `iat`, `iss`, `jti`, `nbf`, and `sub`.

For a full list of features, see [the features of EasyJWT](https://easyjwt.readthedocs.org/en/latest/#features).

## System Requirements & Installation

Flask-EasyJWT requires Python 3.6 or newer.

Flask-EasyJWT is available [on PyPI](https://pypi.org/project/flask-easyjwt/). You can install it using your favorite
package manager.

 * PIP:

    ```bash
    python -m pip install flask_easyjwt
    ```

 * Pipenv:

    ```bash
    pipenv install flask_easyjwt
    ```

## Usage

Flask-EasyJWT is used exactly as [EasyJWT](https://github.com/BMeu/EasyJWT). Therefore, this section only describes the
specific features of Flask-EasyJWT and the basic usage. For detailed explanations on how to use EasyJWT (for example,
optional claims, registered claims such as `aud`, `iat`, and `sub`, or verifying third-party tokens), see
[its documentation](https://easyjwt.readthedocs.org/en/latest/#usage).

### Application Setup

You do not need to initialize Flask-EasyJWT with your Flask application. All you have to do (although even this is,
strictly speaking, not required), is to specify some default settings for all of your tokens in the configuration of
your Flask application. These settings are:

| Configuration Key        | Description |
|--------------------------|-------------|
| `EASYJWT_KEY`            | The key that will be used for encoding and decoding all tokens. If `EASYJWT_KEY` is not specified, Flask-EasyJWT will fall back to Flask's `SECRET_KEY` configuration value. |
| `EASYJWT_TOKEN_VALIDITY` | The validity of each token after its creation. This value can be given as a string (that is parsable to an integer), an integer, or a `timedelta` object. The former two are interpreted in seconds. |

You can specify these configuration values as any other configuration values in your Flask application, for example,
using a mapping in your code:

```python
from datetime import timedelta
from flask import Flask

app = Flask(__name__)
app.config.update(
    EASYJWT_KEY='Super secret key',
    EASYJWT_TOKEN_VALIDITY=timedelta(minutes=7)
)
```

In this example, all tokens will (by default) be encoded using the (not so secure) string `Super secret key` and will
be valid for seven minutes after they have been created (i.e., after the `create()` method has been called on the token
object).

Of course, any other way of specifying the configuration values will work as well (see
[Flask's documentation](https://flask.palletsprojects.com/en/1.1.x/config/)).

### Token Specification & Usage

Tokens are specified and used exactly as with [EasyJWT](https://easyjwt.readthedocs.org/en/latest/#usage):

```python
from flask_easyjwt import FlaskEasyJWT

# Define the claims of your token.
class MySuperSimpleJWT(FlaskEasyJWT):

    def __init__(self, key):
        super().__init__(key)

        # Define a claim `name`.
        self.name = None

# Assuming we are within a Flask app context.

# Create a token with some values.
token_object = MySuperSimpleJWT()
token_object.name = 'Zaphod Beeblebrox'
token = token_object.create()

# Verify the created token.
verified_token_object = MySuperSimpleJWT.verify(token)
assert verified_token_object.name == 'Zaphod Beeblebrox'
```

The only difference is that you do not have to pass the key for encoding or decoding the token to the constructor and
`verify()` method, respectively (you still can do so if you do not want to use the default key defined in your
application's configuration).

Additionally, if the configuration value `EASYJWT_TOKEN_VALIDITY` is set, the token will
be valid for the amount specified in this configuration value after it has been created with `create()`. If this
configuration value is not set tokens will not expire. If you explicitly set the expiration date on a token object
this value will always take precedence (if it is not `None`):

```python
import datetime

from flask_easyjwt import FlaskEasyJWT
from flask import Flask

# Define the claims of your token.
class MySuperSimpleJWT(FlaskEasyJWT):

    def __init__(self, key):
        super().__init__(key)

        # Define a claim `name`.
        self.name = None

# Define the default configuration options for FlaskEasyJWT
# in the configuration of your Flask app.
app = Flask(__name__)
app.config.from_mapping(
    EASYJWT_KEY='Super secret key',
    EASYJWT_TOKEN_VALIDITY=datetime.timedelta(minutes=7)
)

# Assuming we are within a Flask app context.

token_object = MySuperSimpleJWT()
token_object.name = 'Zaphod Beeblebrox'

# This token will expire in 15 minutes, even though the default token validity is set to 7 minutes.
token_object.expiration_date = datetime.datetime.utcnow() + datetime.timedelta(minutes=15)
```

Initializing token objects and creating and verifying tokens must be executed within a
[Flask application context](https://flask.palletsprojects.com/en/1.1.x/appcontext/) if you want to use the configuration
values from the application's configuration.

## Acknowledgements

Flask-EasyJWT is just an easy-to-use abstraction layer around José Padilla's
[PyJWT library](https://pypi.org/project/PyJWT/) that does the actual work of creating and verifying the tokens
according to the JWT specification. Without his work, Flask-EasyJWT would not be possible.

## License

Flask-EasyJWT is developed by [Bastian Meyer](https://www.bastianmeyer.eu)
<[bastian@bastianmeyer.eu](mailto:bastian@bastianmeyer.eu)> and is licensed under the
[MIT License]((http://www.opensource.org/licenses/MIT)). For details, see the attached [LICENSE](LICENSE) file.

repository: BMeu/Flask-EasyJWT

repo_name: BMeu/Flask-EasyJWT


text:
---
title: Facette 0.2.2 released
date: 2014-11-16T12:00:00
author: dev
slug: facette-0-2-2-released
---
Here comes the version [0.2.2][release] of Facette; this is a bugfix release:

* Fix invalid metric name when editing graph metrics
* Fix operation groups custom colors management issue
* Fix buggy globbing in source/metric groups
* UI improvements

Unless major bug uncovered, this is the last release before 0.3.0 version.
We're currently working on greatly improving the library administration and
user interface in general. Stay tuned!

[release]: https://github.com/facette/facette/releases/tag/0.2.2

repository: facette/blog

repo_name: facette/blog


text:
# Pic-a-daily

## Introduction

This is the code for the Pic-a-daily, an application to upload, analyse and
share pictures using Google Cloud serverless solutions, namely Cloud Functions,
App Engine, and Cloud Run.

There are 2 versions of the app:

1. Choreographed version using events from Cloud Functions, Pub/Sub, Eventarc.
2. Orchestrated version using Workflows.

## Labs

There is a workshop you can follow to build the app:

* [Lab 1 — Store and analyse pictures](https://codelabs.developers.google.com/codelabs/cloud-picadaily-lab1)
* [Lab 2 — Create thumbnails of big pictures](https://codelabs.developers.google.com/codelabs/cloud-picadaily-lab2)
* [Lab 3 — Run containers on a schedule](https://codelabs.developers.google.com/codelabs/cloud-picadaily-lab3)
* [Lab 4 — Create a web frontend](https://codelabs.developers.google.com/codelabs/cloud-picadaily-lab4)
* [Lab 5 — Image garbage collector](https://codelabs.developers.google.com/codelabs/cloud-picadaily-lab5)
* [Lab 6 — Orchestration with Workflows](https://codelabs.developers.google.com/codelabs/cloud-picadaily-lab6)

## Presentation

There's a [presentation](https://speakerdeck.com/meteatamel/pic-a-daily-serverless-workshop) that accompanies the workshop.

## Architecture - Choreographed (event-driven)

## Architecture - Orchestrated

## Scripts and Terraform

There are shell [scripts](scripts) and [terraform](terraform) configs to setup each lab.

## Solutions used

The app uses the following solutions:

Compute:

* [Cloud Functions](https://cloud.google.com/functions/) — functions as a service
* [App Engine](https://cloud.google.com/appengine/) — application as a service
* [Cloud Run](https://cloud.google.com/run/) — container as a service

Data:

* [Cloud Storage](https://cloud.google.com/storage/) — for storing file blobs (images)
* [Cloud Firestore](https://cloud.google.com/firestore/) — for structured data

Services:

* [Eventarc](https://cloud.google.com/run/docs/quickstarts/events) - to receive events from various Google Cloud sources.
* [Vision API](https://cloud.google.com/vision/) — to analyze pictures
* [Cloud Logging](https://cloud.google.com/logging/) — to track interesting events
* [Cloud Scheduler](https://cloud.google.com/scheduler/) — to run workloads on a schedule
* [Cloud Pub/Sub](https://cloud.google.com/pubsub) — for publish/subscribe-type messaging
* [Cloud Shell](https://cloud.google.com/shell) — for developing online, in the cloud
* [Workflows](https://cloud.google.com/workflows) - to orchestrate services

-------

This is not an official Google product.

gha_language: HCL


text:
# tidal-cli-client
[![Build Status](https://travis-ci.org/okonek/tidal-cli-client.svg?branch=master)](https://travis-ci.org/okonek/tidal-cli-client) [![BCH compliance](https://bettercodehub.com/edge/badge/okonek/tidal-cli-client?branch=master)](https://bettercodehub.com/)

You can now use Tidal on linux. With your loved CLI. <3

## Importand dependencies
You must have MPV and W3M installed.

Install other dependencies with `npm install` and run with `npm run app`.

You can also install `tidal-cli-client` from npm. Install it using command `sudo npm -g i tidal-cli-client@latest`. After installation you can run app from anywhere using command `tidal-cli`.

## Usage instructions
When you open app for the first time you can see a form. Input username (first) and password (second) to the boxes and submit. Then it loads the main app.

### Search
To search for a track, click `:` and enter `track`, then input your query and click enter.
To search for an artist, you should do the same but instead of `track` use `artist`.

To play a song select it on list. To add it to queue press `n` on it.

To close this app simply press escape and to pause playback press `Control-S`.
All the other parts of using the app are intuitive.

The login configuration is kept in your home directory under filename `.tidalConfig.js`. To signin once again you can remove it. And run the app once again.

![Signin form in tidal-cli](https://user-images.githubusercontent.com/24360027/34915577-60560934-f929-11e7-80d0-2282680f09c5.png)

![Searching for artist in tidal-cli](https://user-images.githubusercontent.com/24360027/34915576-60372c3a-f929-11e7-964d-f98fcc951926.png)

![Artist panel in tidal-cli](https://user-images.githubusercontent.com/24360027/34915622-de49b8e0-f929-11e7-9960-e626405d8e71.png)

![Searching for track in tidal-cli](https://user-images.githubusercontent.com/24360027/34915577-60560934-f929-11e7-80d0-2282680f09c5.png)

![Tracks list in tidal-cli](https://user-images.githubusercontent.com/24360027/34915580-60ca4a1a-f929-11e7-9073-5860fcb84a86.png)

repository: natasher/tidal-cli-client

repo_name: natasher/tidal-cli-client