text:
# installing onprem 2.2.0
Server set up not included in this install process. For this install we will use the following server:

<EMAIL_ADDRESS>## prerequisites
For this process, you will need to have 4 links, provided by CARTO, available to you. (these links are generated in [jenkins](http://deploy.int.cartodb.net/view/Sales/job/Omnibus-download-link/build?delay=0sec) (must VM in))
### links:
#### installers
##### builder [installer_url] `this is an expired example link, use a valid one`
***
https://s3.amazonaws.com/com.carto.onpremises.release/2.2.0/carto-builder-2.2.0-rhel-6-x86_64.tar.gz?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=<REDACTED_AWS_ACCESS_KEY>%2F20180613%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20180613T102257Z&X-Amz-Expires=604800&X-Amz-SignedHeaders=host&X-Amz-Signature=c936c573cf30a9f51475229d40be12de5ccbb09edc18cb1429b3621618f31341
***

##### LDS [installer_url] `this is an expired example link, use a valid one`
***
https://s3.amazonaws.com/com.carto.onpremises.release/1.1.0/carto-dataservices-1.1.0-rhel-6-x86_64.tar.gz?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=<REDACTED_AWS_ACCESS_KEY>%2F20180613%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20180613T102308Z&X-Amz-Expires=604800&X-Amz-SignedHeaders=host&X-Amz-Signature=077bf044dcc329a39261d6b22a3e819d84aa9a5d9c543f3aa34872352224e3d2
***
#### data dumps:
##### [geocoder_url] `this is an expired example link, use a valid one`
***
https://s3.amazonaws.com/data.cartodb.net/geocoding/dumps/geocoder-0.0.1.tar.gz?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=<REDACTED_AWS_ACCESS_KEY>%2F20180613%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20180613T102927Z&X-Amz-Expires=604800&X-Amz-SignedHeaders=host&X-Amz-Signature=1a93afc3a0e31807d67b0ce1f0abdfe070af76d1a8c1e554689e4ec7ada32b73
***
##### [observatory_url] `this is an expired example link, use a valid one`
***
https://cartodb-observatory-data.s3.amazonaws.com/do-release-2017_11_29_dac4af93bd/obs.dump?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=<REDACTED_AWS_ACCESS_KEY>%2F20180613%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20180613T102927Z&X-Amz-Expires=604800&X-Amz-SignedHeaders=host&X-Amz-Signature=172162caeb651c8678072aa0a755f76f97e4da0c2a4f1e144dfc0ba2e1a5f59e
***
## getting started
First, you will want to access your server, if you are not already. Our server is called `onprem-install`

```console
$ ssh onprem-install
```
next we will use cURL to download the builder installer
```console
$ curl -o cartobuilder.tar.gz "https://s3.amazonaws.com/com.carto.onpremises.release/2.2.0/carto-builder-2.2.0-rhel-6-x86_64.tar.gz?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=<REDACTED_AWS_ACCESS_KEY>%2F20180613%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20180613T102257Z&X-Amz-Expires=604800&X-Amz-SignedHeaders=host&X-Amz-Signature=c936c573cf30a9f51475229d40be12de5ccbb09edc18cb1429b3621618f31341"
```
once done, the compressed folder will be in the directory. you can check using `ls`
```console
$ ls
cartobuilder.tar.gz
```
we will need to extract the compressed installer:
```console
$ tar xfvz cartobuilder.tar.gz
```
the xfvz options of tar stands for `eXtract File Verbose Zipped`. You will want to change your directory to the newly extracted folder:
```console
$ ls
carto-builder-2.2.0-rhel-6-x86_64  cartobuilder.tar.gz
$ cd carto-builder-2.2.0-rhel-6-x86_64/
$ ls
carto  carto-builder.config  carto-setup.sh  db_dumps  lib  packages  product  setup  templates  tools
```
This directory is where you will get the opportunity to alter the `carto-builder.config` file. Let's enter it now to see what is in it:

```console
$ cat carto-builder.config
CARTO_VERSION="2.2.0"
CARTO_CLIENT_BUILD="carto"
CARTO_USER="carto"
CARTO_PASSWORD="location"
<EMAIL_ADDRESS>CARTO_ORG="organization"
CARTO_DOMAIN="onprem-install.westeurope.cloudapp.azure.com"

# NOTE: Disk quota is in megabytes
CARTO_DISK_QUOTA="1048576"
CARTO_ORG_SEATS="100"
CARTO_ORG_VIEWER_SEATS="1000"
# NOTE: File size is in bytes
CARTO_MAX_IMPORT_FILE_SIZE="1057286400"
CARTO_MAX_IMPORT_TABLE_ROW_COUNT="1000000"

# We will define data and snapshot paths from these two
CARTO_DATA_ROOT_PATH="/data"
CARTO_SNAPSHOT_ROOT_PATH="/data"
# This directory will contain the files shared between builder and resque
CARTO_SHARED_DIR_PATH="/data/shared"
CARTO_TMP_DIR_PATH="/data/tmp"

CARTO_LOG_PATH="/data/log"
CARTO_BACKUP_PATH="/backup"

#=====================================
## Builder
#=====================================
# Allowed IP Configuration (CARTO_XXXX_ADDRESS):        | "<IP_ADDRESS>" | "<IP_ADDRESS>" | "sql-api.carto.com" |
# Allowed BIND IP Configuration (CARTO_XXXX_BIND): | "<IP_ADDRESS>" | "<IP_ADDRESS>" | "<IP_ADDRESS>"           |
# NOTE: Make sure you configure properly both ADDRESS and BIND vars to have a consistent configuration.

# [monit]
CARTO_MONIT=true

# [redis]
CARTO_REDIS_ADDRESS="<IP_ADDRESS>"
CARTO_REDIS_BIND="<IP_ADDRESS>"
CARTO_REDIS_PORT="6379"
# [builder postgresql]
CARTO_BUILDER_POSTGRES_ADDRESS="<IP_ADDRESS>"
CARTO_BUILDER_POSTGRES_BIND="<IP_ADDRESS>"
CARTO_BUILDER_POSTGRES_PORT="5432"
# [nginx]
CARTO_NGINX_ADDRESS="<IP_ADDRESS>"
CARTO_NGINX_BIND="<IP_ADDRESS>"
CARTO_NGINX_HTTP_PORT="80"
CARTO_NGINX_HTTPS_PORT="443"
# [sql-api]
CARTO_SQL_API_ADDRESS="<IP_ADDRESS>"
CARTO_SQL_API_BIND="<IP_ADDRESS>"
CARTO_SQL_API_PORT="8080"
CARTO_SQL_API_ENTITIES_ACCESS="false"
# [varnish]
CARTO_VARNISH_ADDRESS="<IP_ADDRESS>"
CARTO_VARNISH_BIND="<IP_ADDRESS>"
CARTO_VARNISH_PORT="6081"
CARTO_VARNISH_ADMIN_PORT="6082"
# [maps-api]
CARTO_MAPS_API_ADDRESS="<IP_ADDRESS>"
CARTO_MAPS_API_BIND="<IP_ADDRESS>"
CARTO_MAPS_API_PORT="8181"
# [builder]
CARTO_UNICORN_ADDRESS="<IP_ADDRESS>"
CARTO_UNICORN_BIND="<IP_ADDRESS>"
CARTO_UNICORN_PORT="8888"
# [builder - resque]
# [mailer]
MAIL_FROM=""
MAIL_ADDRESS=""
MAIL_PORT=""
MAIL_USERNAME=""
MAIL_USERNAME_PASSWORD=""
MAIL_AUTHENTICATION=""
MAIL_ENABLE_STARTTLS=false

# Connectors
CARTO_ARCGIS_CONNECTOR_ENABLED=false

#=====================================
## Dataservices
#=====================================
# Allowed IP Configuration (CARTO_XXXX_ADDRESS):        | "<IP_ADDRESS>" | "<IP_ADDRESS>" | "sql-api.carto.com" |

# CARTO_DATASERVICES_ADDRESS="<IP_ADDRESS>"
CARTO_DATASERVICES_PORT="5433"
CARTO_DATASERVICES_USER="geocoder_api" ## postgres user [ dataservices client -> dataservices server]
CARTO_DATASERVICES_DB="db_dataservices"

# Builder analysis
CARTO_DS_ANALYSIS_GEOCODER=false
CARTO_DS_ANALYSIS_HIRES=false
CARTO_DS_ANALYSIS_ISOLINES=false
CARTO_DS_ANALYSIS_ROUTING=false
CARTO_DS_ANALYSIS_DOBSERVATORY=false

# Quotas
CARTO_DS_GEOCODER_QUOTA=400000
CARTO_DS_ROUTING_QUOTA=20000
CARTO_DS_ISOLINES_QUOTA=20000
CARTO_DS_DO_SNAPSHOT_QUOTA=400000
CARTO_DS_DO_GENERAL_QUOTA=999999999
```

The notable things to adjust here are:
```console
CARTO_USER=""
CARTO_PASSWORD=""
CARTO_EMAIL=""
CARTO_ORG=""
CARTO_DOMAIN=""(set this to the server address)

# NOTE: Disk quota is in megabytes
CARTO_DISK_QUOTA=""
CARTO_ORG_SEATS=""
CARTO_ORG_VIEWER_SEATS=""
# NOTE: File size is in bytes
CARTO_MAX_IMPORT_FILE_SIZE=""
CARTO_MAX_IMPORT_TABLE_ROW_COUNT=""
```

to enter and edit any of this information, you can use nano:

```console
$ nano carto-builder.config
```

switch to the root, and ***install gcc if you don't already have it***:

```console
$ sudo su
# yum install gcc
```

**possible problem:** You may run into a warning about limited memory that could stop your install process. If this happens, you will need to edit the `/product/builder.hw_reqs` and lower the requirements.

####`this issue has been fixed in 2.2.1`
>**current known error:** in product/, there is a file named `builder.NEWS.md` that needs to be named `builder.NEWS` instead.
>
>**fix:**
>```console
># mv product/builder.NEWS.md product/builder.NEWS
>```

run the installer:

```console
# ./carto-setup.sh builder
Welcome to CARTO on-premises 2.2.0 installer.

The following account will be created to manage the CARTO Builder:

 - Domain: onprem-install.westeurope.cloudapp.azure.com
 - Organization: organization
 - Admin: carto
 - Password: (not shown, it's available on ./carto-builder.config)

The CARTO Builder will use the following paths:

 - Data: /data
 - Logs: /data/log

NOTE: edit ./carto-builder.config file if you want to change something.

Do you want to continue?' (Y/n): Y
```

This will start the install process.

Once installed, we will install the location data services. Go back to the home directory, then use cURL to download, followed by unzipping the folder, then navigating to it

```console
$ cd
$ curl -o carto-lds-1.1.tar.gz "https://s3.amazonaws.com/com.carto.onpremises.release/1.1.0/carto-dataservices-1.1.0-rhel-6-x86_64.tar.gz?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=<REDACTED_AWS_ACCESS_KEY>%2F20180613%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20180613T102308Z&X-Amz-Expires=604800&X-Amz-SignedHeaders=host&X-Amz-Signature=077bf044dcc329a39261d6b22a3e819d84aa9a5d9c543f3aa34872352224e3d2"
$ tar xfvz carto-lds-1.1.tar.gz
$ cd carto-dataservices-1.1.0-rhel-6-x86_64/
```

look into the config file to see what you can change here:

```console
$ cat carto-dataservices.config
CARTO_VERSION="1.1.0"

CARTO_CLIENT_BUILD="carto"

# We will define data and snapshot paths from these two
CARTO_DATA_ROOT_PATH="/data"
CARTO_SNAPSHOT_ROOT_PATH="/data"

CARTO_LOG_PATH="/data/log"
CARTO_BACKUP_PATH="/backup"

#=====================================
## Dataservices
#=====================================
# Allowed IP Configuration (CARTO_XXXX_ADDRESS):        | "<IP_ADDRESS>" | "<IP_ADDRESS>" | "sql-api.carto.com" |
# Allowed BIND IP Configuration (CARTO_XXXX_BIND): | "<IP_ADDRESS>" | "<IP_ADDRESS>" | "<IP_ADDRESS>"           |
# NOTE: Make sure you configure properly both ADDRESS and BIND vars to have a consistent configuration.

CARTO_DATASERVICES_BIND="<IP_ADDRESS>"
CARTO_DATASERVICES_PORT="5433"
CARTO_DATASERVICES_USER="geocoder_api"
CARTO_DATASERVICES_DB="db_dataservices"

CARTO_DS_GEOCODER_LOG_PATH="$CARTO_LOG_PATH/dataservices/geocoder.log"
CARTO_DS_ROUTING_LOG_PATH="$CARTO_LOG_PATH/dataservices/routing.log"
CARTO_DS_ISOLINES_LOG_PATH="$CARTO_LOG_PATH/dataservices/isolines.log"
CARTO_DS_DO_LOG_PATH="$CARTO_LOG_PATH/dataservices/data_observatory.log"
CARTO_DS_MIN_LOG_LEVEL="info"
CARTO_DS_LOG_FILE_PATH="$CARTO_LOG_PATH/dataservices/dataservices.log"

#=====================================
## Monit
#=====================================
CARTO_MONIT=true

#=====================================
## Builder
#=====================================

CARTO_REDIS_ADDRESS="<IP_ADDRESS>"
CARTO_REDIS_PORT="6379"
```

You will need to set `CARTO_MONIT` here to false

####`this issue has been fixed in 2.2.1`
>**current known error:** in product/, there is a file named `dataservices.NEWS.md` that needs to be named `dataservices.NEWS` instead.
>
>**fix:**
>```console
># mv product/dataservices.NEWS.md product/dataservices.NEWS
>```

**if you ran the installer without fixing this first:** the installer would have made a postgres database, and upon running the installer a second time, you may see this:
```console
[2018-06-19 14:21:41] Running: /opt/carto/dataservices/embedded/bin/psql -U postgres -p 5433 -c 'CREATE DATABASE db_dataservices;'
[2018-06-19 14:21:41] Output: ERROR:  database "db_dataservices" already exists
```
to remedey this, you will need to drop the database before trying to install again. to be extra safe, once installed, we will uninstall the LDS and install it once more.
```console
# /opt/carto/dataservices/embedded/bin/psql -U postgres -p 5433 -c 'DROP DATABASE db_dataservices;'
# ./carto-setup.sh dataservices
# carto-dataservices-uninstall.sh
# ./carto-setup.sh dataservices
```
return to `/data` to download the geocoder and observatory data:
```console
# cd /data
```
```console
# curl -o geocoder-0.0.1.tar.gz "https://s3.amazonaws.com/data.cartodb.net/geocoding/dumps/geocoder-0.0.1.tar.gz?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=<REDACTED_AWS_ACCESS_KEY>%2F20180613%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20180613T102927Z&X-Amz-Expires=604800&X-Amz-SignedHeaders=host&X-Amz-Signature=1a93afc3a0e31807d67b0ce1f0abdfe070af76d1a8c1e554689e4ec7ada32b73"
# tar xfvz geocoder-0.0.1.tar.gz
# mv 0.0.1 db_dumps
```
```console
# curl -o obs.dump "https://cartodb-observatory-data.s3.amazonaws.com/do-release-2017_11_29_dac4af93bd/obs.dump?X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Credential=<REDACTED_AWS_ACCESS_KEY>%2F20180613%2Fus-east-1%2Fs3%2Faws4_request&X-Amz-Date=20180613T102927Z&X-Amz-Expires=604800&X-Amz-SignedHeaders=host&X-Amz-Signature=172162caeb651c8678072aa0a755f76f97e4da0c2a4f1e144dfc0ba2e1a5f59e"
# mv obs.dump obs_2017_11_29_dac4af93bd.dump
```
Load the data:
```console
# carto-dataservices-geocoder.sh load-data db_dumps
```
```console
# carto-dataservices-observatory.sh load-data obs_2017_11_29_dac4af93bd.dump
```
**To Access the resolvable URL in the browser, you will need to use https://**

If you need to update ssl certs:

``` console
# vi /data/production/config/builder/config/app_config.yml
:%s/{old_URL}/{new_URL}/g
:wq
```
you will need to manually replace the old subdomain with the new one in all these:
``` console
# nano /data/production/config/sql-api/production.js
# nano /data/production/config/windshaft/production.js
# nano /data/production/config/nginx/sites-enabled/carto.conf
# nano /data/production/config/nginx/sites-enabled/carto-ssl.conf
# nano /etc/carto-builder.config
```

Can use this tool to upload ssl certificates: https://transfer.sh/

### Mounting new disk to server

- attach a volume to your server from azure portal (an operation from their side that they should know how to do)

- create a partition in the empty drive
``` console
$ sudo su
# fdisk -l #lists all devices for disks attached to Server
# fdisk /dev/sdf # use whatever the disk is, starts an interactive prompt:
# n # new partition, will ask for number, which is the number assigned to it, not how many partitions there are
# #will ask for start and end sectors of the partition, default values will fill the whole disk.
# w # write partition
# fdisk -l # you will see sdf1
```
- create a file system in the partition (so the OS can find files in disk)
``` console
# mkfs.ext4 /dev/sdf1 # make file system as ext4, a linux specific file system in my partition
```
- mount the new partition into a mounting point
``` console
# mount /dev/sdf1 /data # mounts the partiton in the /data directory
```
- persist changes to the server
``` console
# nano /etc/fstab # add a new line with the partition, where to mount(mounting point), the file system, 'defaults  0  0'
```
### screen
you can use screen to ensure you don't quit out of a
``` console
# yum install screen
# screen
```
- to detatch: crtl+a (release) d
- list screens: screen -ls
- to resume: screen -r

repository: alexsroth/pet-projs

repo_name: alexsroth/pet-projs


text:
To style and customize the `Label` widget use the conventional CSS properties and Icon Fonts.
The example below shows a label with icon (using icon font), several CSS properties.

<snippet id='label-css-styles'/>
<snippet id='label-styling-xml'/>

branch_name: refs/heads/master

extension: md

gha_language: JavaScript

license_type: permissive


text:
*SISMEMBER* tests if the given value is in the set.

    SISMEMBER superpowers "flight" => true
    SISMEMBER superpowers "reflexes" => false

*SMEMBERS* returns a list of all the members of this set.

    SMEMBERS superpowers => ["flight","x-ray vision"]

*SUNION* combines two or more sets and returns the list of all elements.

    SADD birdpowers "pecking"
    SADD birdpowers "flight"
    SUNION superpowers birdpowers => ["flight","x-ray vision","pecking"]

license: MIT

extension: markdown


text:
# tflite-react-native example

Use tflite-react-native plugin to run model on images.

![](yolo.jpg)

## Prerequisites

1. Download the folder `models` and its contents from https://github.com/shaqian/tflite-react-native/tree/master/example/models. Place the folder at the root of ./example.

2. Open ./example/ios/example.xcworkspace in XCode. Right click on the `example` in the left panel, click **Add Files to "example"...**, select the `models` folder.

3. Copy `models` folder and paste it in ./example/android/app/src/main/assets.

## Installation

```
npm install
```

* For iOS, TensorFlow Lite is installed using POD:

```
cd ios
pod install
```

* For Android, a conversion to AndroidX is necessary (for now):

```
npm run jetify
```

## Run the App

### iOS

```
react-native run-ios
```

### Android

```
react-native run-android
```

repository: aftadizca/tflite-react-native

gha_license_id: MIT

repo_name: aftadizca/tflite-react-native


text:
---
layout: post
title: Android 常见问题
published: true
date:   2016-08-26 11:46
categories:
tags:
comments: true
description: more
---

`Intent` 常见用法

To start an activity: You can start a new instance of an Activity by passing an Intent to startActivity() method.
To start a service: You can start a service to perform a one-time operation (such as download a file) by passing an Intent to startService().
To deliver a broadcast: You can deliver a broadchttps://jira.hotels.com/secure/attachment/211274/SQM_new_design_2_full_CORRECTED.pngast to other apps by passing an Intent to sendBroadcast(), sendOrderedBroadcast(), or sendStickyBroadcast().


text:
# peerflix-gui

## Motivation

Originally for my girlfriend who have difficulties to use the terminal :)

This sofware is developed using nwjs.

## Installation
### From the source

Zip all the file (excluded ```/bin```  ```/README.md``` ```/LICENSE``` and all git specific files)
Rename the .zip file into .nw

### Start the software

Simply execute with nw

```
nw ~/path/to/yourFile.nw
```

## Screenshot

![screenshot](screenshot.png)

repository: titouancreach/peerflix-gui

repo_name: titouancreach/peerflix-gui


text:
**Archived version, further development moved to the [Randonnees-Datatrek fork](https://github.com/Randonnees-Datatrek/data-trek-2020)**

# Data.Trek 2020
## Project Management

### Essential elements of a regular, reproducible project folder:

- Code
- Input
- Output
- README
- LICENSE
.git

### Structure example

```
my_project/
- code/			# functions, scripts, routines
- data/			# main data folder
	- raw/		# !NEVER TOUCH DIZ!
	- clean/	# if you touched raw data, you put it here now
- output/		# everything that your code spitz
	- fig/ 	        # may be figures
 	- results/ 	# or other things
- README.md 	        # your future me won't know what this project is about
- LICENSE 	        # let people know what they can do with your project
- .git 	             	# git things (we'll get to that later)
```

gha_language: R


text:
# tucsonjs-logo

Draws the [TucsonJS](http://www.tucsonjs.org/) logo using JavaScript.

## Synopsis

![Screenshot of tucsonjs-logo running in svg-playground](http://www.limulus.net/projects/svg-playground/screenshot.png?1)

This module uses [svg-playground](https://www.npmjs.com/package/svg-playground) and [vecs](https://www.npmjs.com/package/vecs) to draw the TucsonJS logo.

## Usage

```
git clone https://github.com/limulus/tucsonjs-logo.git
cd tucsonjs-logo
npm install
npm start
```

With svg-playground, you can edit the code on the right-hand side of the screen and immediately see your changes. Your changes are also immediately saved to disk. Simply use git for version control. Export the SVG using ⌘E on OS X or ctrl-E on other systems, then save the newly opened window as source.

repository: webstackers/tucsonjs-logo

repo_name: webstackers/tucsonjs-logo


text:
# Laravel Lang Bundler
[![Latest Stable Version](https://img.shields.io/packagist/v/zachleigh/laravel-lang-bundler.svg)](//packagist.org/packages/zachleigh/laravel-lang-bundler)
[![License](https://img.shields.io/badge/license-MIT-brightgreen.svg)](//packagist.org/packages/zachleigh/laravel-lang-bundler)
[![Build Status](https://img.shields.io/travis/zachleigh/laravel-lang-bundler/master.svg)](https://travis-ci.org/zachleigh/laravel-lang-bundler)
[![Quality Score](https://img.shields.io/scrutinizer/g/zachleigh/laravel-lang-bundler.svg)](https://scrutinizer-ci.com/g/zachleigh/laravel-lang-bundler/)
[![StyleCI](https://styleci.io/repos/72352058/shield?style=flat)](https://styleci.io/repos/72352058)
[![Total Downloads](https://img.shields.io/packagist/dt/zachleigh/laravel-lang-bundler.svg)](https://packagist.org/packages/zachleigh/laravel-lang-bundler)

##### Make bundles of translation values.

### Contents
  - [Why](#why)
  - [Upgrade Information](#upgrade-information)
  - [Install](#install)
  - [Usage](#usage)
  - [Advanced Usage](#advanced-usage)
  - [Commands](#commands)
  - [Configuration](#configuration)
  - [Limitations](#limitations)
  - [Testing](#testing)
  - [Contributing](#contributing)

### Why
Why use this package? Because this sucks:
```html
<component
    welcome={{ trans('home.welcome') }}
    login={{ trans('home.login') }}
    signup={{ trans('home.signup') }}
    profile={{ trans('user.settings.profile') }}
    friends={{ trans('user.home.friends') }}
    intro={{ trans('user.home.intro') }}
    body={{ trans('user.home.body') }}
></component>
```
And this is so much better:
```html
<component
    :lang={{ transB('bundle_name')->toJson() }}
></component>
```

### Upgrade Information
##### Version 1.0.* to Version 1.1.*
Version 1.1.0 drops support for PHP versions lower than 7.1.

##### Version 0.9.* to Version 1.0.0
Version 1.0.0 is more a confimation of the current api and usage than anything else. Adds support for Laravel 5.4. If using Laravel 5.3, please use [Version 0.9.11](https://github.com/zachleigh/laravel-lang-bundler/tree/v0.9.11):
```
composer require zachleigh/laravel-lang-bundler:0.9.*
```

### Install
##### 1. Install through composer
```
composer require zachleigh/laravel-lang-bundler
```

##### 2. Register the service provider
In Laravel's config/app.php file, add the service provider to the array with the 'providers' key.
```
LaravelLangBundler\ServiceProvider::class
```

##### 3. Publish the config file:
```
php artisan vendor:publish --tag=config
```

##### 4. Create a 'bundles' directory in resources/lang/.
Do it manually or use the command:
```
php artisan langb:start
```

### Usage
##### 1. Make a bundle.
Imagine we have two lang files, one called 'home.php' and one called 'user.php'.

home.php
```php
    'welcome' => 'Welcome!',
    'login' => 'Login',
    'signup' => 'Signup',
```

user.php
```php
    'profile' => 'Your Profile',
    'friends' => 'Your Friends',
    'body' => 'Enter body below',
```
We want all of these values in one bundle.

Simply register your bundle as an array anywhere in the bundles directory. For example, in the bundles directory, you could create a folder called 'components' and in it a file called 'bundle_name' that looks like this:
```php
return [
    'home.welcome',
    'home.login',
    'home.signup',
    'user.profile',
    'user.friends',
    'user.body'
];
```
Obviously, 'bundle_name' is the name of the bundle. The other values represent keys found in the above lang files.

Like in other lang folders, any file/folder in the bundles directory is treated as a level in an array. So in the above example, our file path looks like this:

lang/bundles/components/bundle_name.php

The path for the 'bundle_name' bundle would be 'bundles.components.bundle_name'. It is also possible to create multiple named bundles within a single file, but this is not recommended because you can not use auto-aliasing for multi-bundle files.

##### 2. Get the bundle using the transB() helper function.
Get your translated bundle by passing the bundle path to the transB() helper function.
```php
transB('bundles.components.bundle_name');
```
Or use the auto-aliased name:
```php
transB('bundle_name');
```
transB() returns a collection of translated values keyed by the original translation key. Continuing the example above, transB() would give us a collection that contains the following array:
```php
[
    'welcome' => 'Welcome!',
    'login' => 'Login',
    'signup' => 'Signup',
    'profile' => 'Your Profile',
    'friends' => 'Your Friends',
    'body' => 'Enter body below',
];
```

##### 3. Pass parameters to your bundle.
Like with the standard trans() function, you may pass parameters to the transB() function as the second argument.
```php
transB('bundle_name', ['parameterName' => $value]);
```
If your bundle has conflicting parameter names, you can namespace them. In this example, three values require a `user` parameter.

user.php translation file:
```php
return [
    'welcome_user' => 'Welcome :user',
    'message_to'   => 'You sent a message to :user',
    'invite_from'  => 'You have an invite from :user'
];
```
Bundle file:
```php
return [
    'user.welcome_user',
    'user.message_to',
    'user.invite_from'
];
```
Avoid the naming conflict by namespacing the parameters when passing them to transB():
```php
transB('bundle_name', [
    'welcome_user.user' => 'Bob',
    'message_to.user' => 'Sally',
    'invite_from.user' => 'George'
]);
```

##### 4. Pluralize values
It is possible to pluralize lang items by passing a namespaced 'choice' parameter in the transB() function parameters. For example, if our lang file value looked like this:
```php
'inbox_status' => 'You have a new message.|You have new messages'
```
We could register it in our bundle normally:
```php
'home.inbox_status'
```
And then when calling transB(), pass a parameter called 'inbox_status.choice' with the desired choice value:
```php
transB('bundle_name', ['inbox_status.choice' => 3]);
```
The result will look be the pluralized string "You have new messages".

### Advanced Usage
#### Modify return keys and values
To modify the key and value in the returned translation array, use the bundle_item() helper on a specific bundle item.
```php
bundle_item($id, $type, $parameters = []);
```
$id is the lang key. $type must be in the following format: 'target_type'. 'target' declares what item is to be affected by the modification and can be set to either 'value', 'key', or 'both'. 'type' declares the type of modification (callback, change etc.). $parameters is an array of parameters to be sent to the class that performs the modification.

If using the same example as above we wanted to convert the 'welcome_user' value to all caps, we could accomplish it by using the bundle_item() helper function in the bundle file.
user.php translation file:
```php
return [
    'welcome_user' => 'Welcome :user',
    'message_to'   => 'You sent a message to :user',
    'invite_from'  => 'You have an invite from :user'
];
```
Bundle file:
```php
return [
    bundle_item('user.welcome_user', 'value_strtoupper'),
    'user.message_to',
    'user.invite_from'
];
```
Wrap the bundle key 'user.welcome_user' in the bundle_item() global function and pass the translation key ($id) plus the type (perform a 'strtoupper' on the returned 'value'). This returns the following values (assuming a non-namespaced user variable with the value 'Bob'):
```
[
    'welcome_user' => 'WELCOME BOB',
    'message_to'   => 'You sent a message to Bob',
    'invite_from'  => 'You have an invite from Bob'
];
```

If we wanted to do the same to the key, we could do this:
```php
return [
    bundle_item('user.welcome_user', 'key_strtoupper'),
    'user.message_to',
    'user.invite_from'
];
```

Or, if we wanted to perform the modification on both the key and the value:
```php
return [
    bundle_item('user.welcome_user', 'both_strtoupper'),
    'user.message_to',
    'user.invite_from'
];
```

##### Available modifiers
###### callback
Perform a callback on a key or value. Requires a 'callback' parameter.
```php
bundle_item('user.welcome_user', 'value_callback', [
    'callback' => 'function_name'
]),
```

###### change
Change a key to a new value. Does nothing to values. Requires 'new' parameter.
```php
bundle_item('user.invite_from', 'key_change', [
    'new' => 'newKey'
]),
```
###### explode
Explode by given delimiter. Does nothing to key. Requires 'delimiter' parameter.
```php
bundle_item('user.invite_from', 'value_explode', [
    'delimiter' => ' '
]),
```

###### strtolower
Lowercase entrire string.
```php
bundle_item('home.invite_from', 'value_strtolower')
```

###### strtoupper
Capitalize entire string.
```php
bundle_item('home.invite_from', 'value_strtoupper')
```

###### ucfirst
Make first character in string capitalized.
```php
bundle_item('home.invite_from', 'value_ucfirst')
```

###### values
If translation value is an array, run array_values() on array and return only values keyed by integers. Does nothing to keys.
```php
bundle_item('home.months', 'value_values')
```

##### Creating your own modifier
Use the 'mod' command to create a new mod class in App/LangBundler/Mods:
```
langb:mod {name}
```

There are two abstract methods that must be implemented in your class:
```php
    /**
     * Alter key and return.
     *
     * @param string $key
     *
     * @return string
     */
    abstract public function key($key);

    /**
     * Alter value and return.
     *
     * @param mixed $value
     *
     * @return mixed
     */
    abstract public function value($value);
```
The same class is used to modify both the value and key. Define your modification and return the desired key/value.

### Commands
##### php artisan langb:start
Get started by creating a bundles directory in your lang folder.

##### php artisan langb:new {path}
Create a new bundle file located at path. For example:
```
php artisan langb:new components.user.profile
```
This would create the file lang/bundles/components/user/profile.php with an empty returned array.

##### php artisan langb:mod {name}
Create an empty mod template in App/LangBundler/Mods.

### Configuration
##### aliases
To shorten the name of bundles, you can register aliases in config.
```php
'aliases' [
    'alias' => 'full.path.to.bundle'
];
```
And then simply use the alias istead of the path in transB():
```php
transB('alias');
```

##### key_transform
If you wish to transform lang file keys to snake_case, StudlyCase, or camelCase, set `key_transform` to 'snake_case', 'studly_case', or 'camel_case'. Default value is 'none'.
For example, this bundle contains snake cased variables:
```php
return [
    'user.welcome_user',
    'user.message_to',
    'user.invite_from'
];
```
But in your javascript, you want to use came cased variables, set `key_transform` to 'camel_case' to get this bundle:
```php
return [
    'welcomeUser' => 'Welcome user!',
    'messageTo' => 'Message to user',
    'inviteFrom' => 'You have an invitation from user!',
];
```
Many other simple string functions (ucfirst, strtoupper, etc.) also work.

key_transform is global and will transform all keys in your project. If you wish to transform a single key, see [modify return keys and values](#modify-return-keys-and-values).

##### global_key_namespace
If you keep all your translations in a single file, you can set `global_key_namespace` to the name of the file to save yourself some typing. For example, if all your translations are in a file called 'translations.php', you would have to register a bundle like this:
```php
return [
    'bundle_name' => [
        'translations.home',
        'translations.navigation',
        'translations.menu',
        'translations.login'
    ];
];
```
However, if you set `global_key_namespace` to 'translations', you could register it like this:
```php
return [
    'bundle_name' => [
        'home',
        'navigation',
        'menu',
        'login'
    ];
];
```

### Testing
```
composer test
```

### Contributing
Contributions are more than welcome. Fork, improve and make a pull request. For bugs, ideas for improvement or other, please create an [issue](https://github.com/zachleigh/laravel-lang-bundler/issues).

repository: zachleigh/laravel-lang-bundler

gha_language: PHP

repo_name: zachleigh/laravel-lang-bundler


text:
# Selected Topics in Mathematical Optimization

![](totoro.png)

*Edition 2020-2021*

**Michiel Stock**

**Maxime Van Haeverbeke**

This repository contains the notes and exercises of the optimization course given in the Master of Bioinformatics Bioscience Engineering and Systems Biology at Ghent University.

The goal of this course is to give students a general overview of the rich field of mathematical optimization. This course will put a particular emphasis on practical implementations and performance. After this course, students should be able to formulate problems from computational biology as optimization problems and be able to interpret, understand, and implement new optimization algorithms.

As of 2020, we have chosen to move this course from Python to the new [Julia programming language](https://julialang.org/). This is not because we are too cool for Python, but because Julia is supremely suited for scientific computing. Furthermore, Julia code can be made extremely performant, on par with optimized C code. We don't expect students to fully optimize code, but throughout, we will give hints and guidelines on how to generally improve implementations, in Julia or other programming languages. No prior knowledge of Julia is needed. We will learn while doing it! To get started, you can check out our [quick start guide](chapters/00.Introduction/00-GetGoingWithJulia.md) and if you get lost, we recommend taking a look at the [cheat sheet](https://juliadocs.github.io/Julia-Cheat-Sheet/).

## Course content

1. Intro to Julia and bracket search
2. Quadratic optimization
3. Automatic differentiation
4. Unconstrained convex optimization
5. Constrained convex optimization
6. Optimal transportation
7. Minimum spanning trees
8. Shortest path problems
9. NP-hard problems
10. Heuristics and metaheuristics

## Using this repo

If you have *Julia* and *IJulia*-notebooks installed, clone the repo (check the section on GitHub below if you don't know what this means) and work locally in the notebooks, this is recommended as it is the only way to save your work. Otherwise, click on the badge below to open a Binder session or check the *installation instructions* below to install *Julia* and *IJulia*-notebooks.

[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/MichielStock/STMO/master)

While using Binder is convenient in the short term, it will take a while to start up every time, and it will only allow you to follow along with the notebooks, without having the ability to save your work.

All notebooks and pdf notes are generated from the `.jmd` files in all the chapter folders. These can be build by running the `build.jl` script in Julia:

```julia
include("build.jl")
```

Beware that building the course will take a while.

In addition to the Jupyter notebooks and PDF notes, running this script also generates some example figures. We encourage students to take a look in the `scrips/` folder for some examples illustrating the theory. All PDF notes will also be made available on Ufora.

This repository also represents a Julia package, which can be loaded in the Julia REPL.

```julia
using STMO
```

This package contains the solution to most implementation exercises in this course. It also includes a wealth of helper functions for plotting etc.

## Installation instructions

### Github

Using Git or Github desktop is recommended for this course. In case you don't already have git or Github installed, this can be done by following the instructions for your operating system here [here](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git) for Git and [here](https://desktop.github.com/) for GitHub desktop. Using git, clone (i.e., download the files of) the course repository by typing
```
git clone https://github.com/MichielStock/STMO.git
```
In the command prompt, after navigating to where you want to save the course files.

### Installing Julia

1. Download the *Julia* binaries for your system [here](https://julialang.org/downloads/) we suggest installing the current stable release, v1.5.0
2. Check the [Platform Specific Instructions](https://julialang.org/downloads/platform/) of the official website to install *Julia*

### Installing the STMO package

All required packages for this course are bundled together in the STMO package, which can be installed as follows.

In Julia, enter *package mode* by pressing the "`]`" key.  All required packages will be installed by then typing (or copying) at the `(v1.5) pkg> ` prompt:
```
add https://github.com/MichielStock/STMO.git
```

> This course is work in progress and will likely be updated throughout the year. At the start of every lecture, it is a good idea to update the package by typing `update STMO` in the package mode and rebasing your repository to be in sync with the `master` branch.

 To simplify installation, you can alternatively type the following in Julia, at the `julia>` prompt:
```julia
using IJulia
```
to install the IJulia kernel.

## Gitter

While the course is given remotely, you can ask questions about the project and chapters via Gitter:

[![Gitter](https://badges.gitter.im/STMOUGent/community.svg)](https://gitter.im/STMOUGent/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)

repository: chrisgalgojr/STMO

repo_name: chrisgalgojr/STMO


text:
# URL Swap Firefox Addon (Find and Replace).

The URL Swap extension changes the root to another URL that you specify in the Preferences window.

https://addons.mozilla.org/en-US/firefox/addon/url-swap/?src=search

This is an old Firefox Addon project (2008). I open today the source. 22/09/2015

Be free to fork it and pull request to improve it.

### About this Add-on

Swap windows URL root to another (replace root URL) like :

www.google.com/search?&q=Autre+planète+Design+Studio+Paris&...

to:

www.google.fr/search?&q=Autre+planète+Design+Studio+Paris&...

###OR

localhost

to:

yourWebSite.com (your web pages)

...

###Howto :

Open Preferences URL Swap, to manage your URLs.
Click on URL swap icons (Right Bottom Corner) to swap the current URL.

FF4 compatible NOW!

### General usage:

Swap between development and live version

Swap between different website versions

Swap between different languages like (/fr/ to /en/)

And More... ;)

## License

Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/

repository: thierryc/URL-Swap-Firefox-Addons

repo_name: thierryc/URL-Swap-Firefox-Addons


text:
# large

 * [Large Shell Pasta With Seafood Sauce](../../index/l/large-shell-pasta-with-seafood-sauce-2814.json)
 * [Roasted Cod On Large Garlic Croutons](../../index/r/roasted-cod-on-large-garlic-croutons-242490.json)
 * [Easy Chicken Tetrazzini For A Large F](../../index/e/easy-chicken-tetrazzini-for-a-large-f.json)
 * [Large Salmon Patties](../../index/l/large-salmon-patties.json)
 * [Large Soft Pretzels Quick](../../index/l/large-soft-pretzels-quick.json)
 * [Large White Birthday Cake](../../index/l/large-white-birthday-cake.json)
 * [Citrus Sage Roast Turkey With Gravy Large Crowd 51137800](../../index/c/citrus-sage-roast-turkey-with-gravy-large-crowd-51137800.json)
 * [Large Shell Pasta With Seafood Sauce 2814](../../index/l/large-shell-pasta-with-seafood-sauce-2814.json)
 * [Roasted Cod On Large Garlic Croutons 242490](../../index/r/roasted-cod-on-large-garlic-croutons-242490.json)


text:
# Rationale

Consider the following functionality:

```java
fetchUsers(userIds)
    .map(user -> {
        final List<UserDto> friends = fetchUsers(user.getFriends());
        return new UserWithFriends(user, friends);
    });
```

This piece of code, as simple as it looks, has potential for optimisation.
Let's improve it!

## Batching

First up, **batching**. We're doing one query per element in `userIds` to
fetch their friends - and this could just as well be one query over all
the friend IDs:

```java
final List<UserDto> users     = fetchUsers(userIds);
final List<Integer> friendIds = users.bind(UserDto::getFriends);
final List<UserDto> friends   = fetchUsers(friendIds);
```

Of course, now we have to assemble `UserWithFriends` which gets a bit more
intricate:

```java
final HashMap<Integer, UserDto> friendById =
    HashMap.iterableHashMap(friends.map(UserDto::getId).zip(friends));

users.map(user -> {
    final List<UserDto> friends = user.getFriends().map(id -> friendById.get(id).some());
    return new UserWithFriends(user, friends);
});
```

We had to create a lookup table and then manually put every fetched `UserDto` to the
right place. It's not terrible but seems a bit hard.

## Deduplication

Next up, **deduplication**. We might be passing the same ID multiple times to `fetchUsers`
when querying the friends. This is not necessarily a big problem depending on the datastore
but it's definitely a few unnecessary bytes that are sent over the wire. Easily solved,
though, let's dedupe:

```java
final HashSet<Integer> uniqueUserIds = HashSet.iterableHashSet(userIds);
final List<UserDto> users            = fetchUsers(uniqueUserIds.toList());
final HashSet<Integer> friendIds     = HashSet.iterableHashSet(users.bind(UserDto::getFriends));
final List<UserDto> friends          = fetchUsers(friendIds.toList());
...
```

Admittedly, this won't look as bad once we extract a generic `dedupe` function that
handles conversion to a set and back. This exercise is left to the reader.

## Caching

Finally, **caching**. When fetching the initial set of users (`fetchUsers(userIds)`) there
is a chance that we retrieved data that's then fetched again when querying the friends. Best
case, it's a waste of bandwidth; worst case, the second fetch returns different data than
the first one! For the same entity!

Still, easy to address:

```java
final HashSet<Integer> uniqueUserIds = HashSet.iterableHashSet(userIds);
final List<UserDto> users            = fetchUsers(uniqueUserIds.toList());
final HashSet<Integer> friendIds     = HashSet.iterableHashSet(users.bind(UserDto::getFriends));
uniqueUserIds.forEach(friendIds::delete);
final List<UserDto> friends          = fetchUsers(friendIds.toList());
```

## Full Example

The following piece of code is the "optimised" variant of the simple functionality
initially presented:

```java
final HashSet<Integer> uniqueUserIds = HashSet.iterableHashSet(userIds);
final List<UserDto> users            = fetchUsers(uniqueUserIds.toList());
final HashSet<Integer> friendIds     = HashSet.iterableHashSet(users.bind(UserDto::getFriends));
uniqueUserIds.forEach(friendIds::delete);
final List<UserDto> friends          = fetchUsers(friendIds.toList());
final HashMap<Integer, UserDto> friendById =
    HashMap.iterableHashMap(friends.map(UserDto::getId).zip(friends));

users.map(user -> {
    final List<UserDto> friends = user.getFriends().map(id -> friendById.get(id).some());
    return new UserWithFriends(user, friends);
});
```

There is so much noise in there because of our optimisation attempts. It's hard
to understand what the code is doing, and even a cleaned up version does not
improve the situation significantly:

```java
final List<UserDto> users                  = fetchUsers(dedupe(userIds));
final HashSet<Integer> friendIds           = users.bind(UserDto::getFriends);
final List<UserDto> friends                = fetchUsers(dedupe(remove(friendIds, userIds)));
final HashMap<Integer, UserDto> friendById = groupById(friends);

users.map(user -> {
    final List<UserDto> friends = findFriends(friendById, user.getFriends());
    return new UserWithFriends(user, friends);
});
```

## What now?

Here's he thing: There is no need for manual optimisation! If we step away from
imperative code and represent the fetching and transformation as a data structure,
an external engine can inspect it and decide on the best way of producing a
result. This is what haxl and haxlike do!

```java
final Node<List<UserDto>> users = value(userIds).traverse(FetchUser::new);
final Node<List<UserWithFriends>> node =
    users.traverse(user -> {
        final Node<List<UserDto>> friends = value(user.getFriends()).traverse(FetchUser::new);
        return friends.map(xs -> new UserWithFriends(user, xs));
    });

engine.resolve(node);
```

The above is already very close to our initial example, basically identical
once we extract `value(ids).traverse(FetchUser::new)` into a `fetchUsers`
function.

However, it has an unnecessary notion of ordering (even though the underlying engine
will not care about that): First we resolve all the users, then we resolve all the
friends.

The following is equivalent, and arguably easier to understand because it only
concerns itself with exactly one user:

```java
public Node<UserWithFriends> fetchUserWithFriends(int id) {
    return new FetchUser(id).map(user ->
        value(user.getFriends())
            .traverse(FetchUser::new)
            .map(friends -> new UserWithFriends(user, friends)));
}
// ...
engine.resolve(
    value(userIds)
        .traverse(this::fetchUserWithFriends));
```

And there we are: Straightforward code that will be executed efficiently
by haxlike's engine. The best of both worlds!

repository: xsc/haxlike

gha_language: Java

repo_name: xsc/haxlike


text:
# VISOR: the Western Washington University Visible-Infrared Spectral Browser

*a marslab project*

[![DOI](https://zenodo.org/badge/238997928.svg)](https://zenodo.org/badge/latestdoi/238997928)

## Description

VISOR is a search and visualization engine for reflectance spectra in
visible and infrared wavelengths. It is currently in open beta. It has a
publicly-accessible web version, [which you can access at https://www.westernreflectancelab.com/visor/](https://www.westernreflectancelab.com/visor/).

We developed VISOR in support of our research group's analyses of hyper-
and multi-spectral imaging data of planetary surfaces, and to share
laboratory data acquired at WWU. We hope it will be a useful resource for
other planetary researchers and the larger scientific community.

## Usage

The easiest way to use VISOR is simply to access the live site:
[https://www.westernreflectancelab.com/visor/](https://www.westernreflectancelab.com/visor/).

If you would like to install a local copy for your personal use, perhaps to
ingest and manipulate your own data, please see
[the local installation guide](visor_local_installation_guide.md).
Some reference tricks and recipes for advanced local usage can be found in
the [programming manual](visor_programming_manual.ipynb).

VISOR does not come with a populated database. If you would like a populated
database to experiment with, please contact<EMAIL_ADDRESS>with a description of your use case.

## Licensing

This code carries a BSD 3-Clause license. You can do nearly anything that
you want with it. The data available via the web portal is **not** covered
by this license, nor is it, generally, copyright of Million Concepts or
Western Washington University. Please reference the metadata of any spectra
you use in order to properly cite their sources.

## Attribution

VISOR was created by:

* Michael St. Clair and Chase Million -- software development and UX design
* Melissa Rice -- research and requirements design

VISOR is based on an older tool developed by Kyle Mellander with significant
input from Darian Dixon and students in the WWU Mars Lab.

gha_language: Python


text:
Pure Admin v2.0
===============

Simple HTML Based Admin Panel.

# Screenshot

![Login Screen](https://github.com/uretgec/pure-themes/raw/screenshot/pure-admin/screen_login.JPG)
![Dashboard Screen](https://github.com/uretgec/pure-themes/raw/screenshot/pure-admin/screen_dashboard.JPG)
![List Screen](https://github.com/uretgec/pure-themes/raw/screenshot/pure-admin/screen_list.JPG)
![Form Screen](https://github.com/uretgec/pure-themes/raw/screenshot/pure-admin/screen_form.JPG)

# Pages

1. Login
2. Register
3. Dashboard
4. Post List
5. Post Form
6. Option List
7. Option Form
8. Profile

# Used Wonderful Thing

* PureCSS https://github.com/yui/pure/ - http://purecss.io/

* Made By PureBuilder https://github.com/fikiruretgeci/pure-builder

repository: uretgec/pure-themes

repo_name: uretgec/pure-themes


text:
+++
title = "Eagle eyes"
# subtitle = ""

date = 2019-04-07T00:00:00
# lastmod = 2019-04-07T00:00:00

draft = false

# Authors. Comma separated list, e.g. `["Bob Smith", "David Jones"]`.
# authors = ["admin"]

# tags = ["Academic"]
# summary = ""

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

# Featured image
# To use, add an image named `featured.jpg/png` to your project's folder.
[image]
  # Caption (optional)
  caption = "Sorry for the low-quality image."

  # Focal point (optional)
  # Options: Smart, Center, TopLeft, Top, TopRight, Left, Right, BottomLeft, Bottom, BottomRight
  focal_point = ""

  # Show image only in page previews?
  preview_only = false

# Set captions for image gallery.

# [[gallery_item]]
# album = "gallery"
# image = "Professor_Dr_Hausman.jpg"
# caption = ""

+++

In one of the Econometrics sessions in this weekend conference, the person above pictured was listening a 20-minutes presentation. As anyone can imagine, these sessions are too short, and therefore, hardly you can have a reasonable (full) view of the paper being presented. However, at the end of this specific presentation:

**CHAIR**: Questions?

**PERSON**: Just two observations. First one, and the least important one is how you constructed your likelihood function out of a Poisson distribution. But more importantly is how you modeled you equilibrium equations. In this case, your errors may have some issues, such as a type of correlation, and this might be a concern.

**PRESENTER**: (smiling) Professor Hausman, you sound exactly like my referee! These are the two topics mentioned in the review.

**PERSON (Professor Dr. Hausman)**: (smiling) Well, I swear I wasn't your referee.

Takeaway: perhaps, in the day that you can spot the `truly important` issues with this easiness (and effortless and quickly), this could be a sign that you reached another level in your field. Professor Hausman (yes, the same from the Durbin-Wu-Hausman test of endogeneity) didn't need the time to read and review the paper. He spotted "from far away" what matters.

In my opinion, the key point here are the `truly important` issues. Not those irrelevant comments, raising concerns that make no difference to what is being studied, or that would just produce infinitesimal changes with no marginal benefits to the final interpretation. Typically, these cosmetic observations play no role to the core model.

# {{< gallery >}}


text:
## Tensorflow object detection example

### Prerequisites:
Tensorflow and models/research/object_detection need to be installed
https://github.com/tensorflow/models/blob/master/research/object_detection/g3doc/installation.md

### Usage:
Run in this order:
  1) to_tfrecords.py
  2) models/research/object_detection/train.py
          modify ssd_mobilenet_v1.config to use paths on your system
          Needs BSTLD downloaded and extracted first
  3) model_freezer.py to adapt models for easier loading
  4) inference.py to use trained and frozen models

Each file should come with some instructions

repository: bilalsal/bstld

repo_name: bilalsal/bstld


text:
README
-------

This module provides arithmetic primitives operations that are useful to implement
cryptographic schemes over curve edwards25519, includes:
1.  Arithmetic functions for point addition, doubling, negation, scalar multiplication
    with an arbitrary point, with the base point, etc.
2.  Arithmetic functions dealing with scalars modulo the prime order L of the base point.

This modules was port of Golang `edwards25519` library from [edwards25519](https://github.com/FiloSottile/edwards25519) to the V language.

About Edwards25519
------------------

Twisted Edwards curves are a family of elliptic curves allowing complete addition
formulas without any special case and no point at infinity.
Curve edwards25519 is based on prime 2^255 - 19 for efficient implementation.
Equation and parameters are given in RFC 7748.

repository: vlang/v

gha_language: V

repo_name: vlang/v


text:
description: Parses the encoded key to keys and weights.

<meta itemprop="name" content="tfr.utils.parse_keys_and_weights" />
<meta itemprop="path" content="Stable" />

# tfr.utils.parse_keys_and_weights

    View source on GitHub

Parses the encoded key to keys and weights.

tfr.utils.parse_keys_and_weights(
    key: str
) -> Dict[str, float]

This parse function will remove all spaces. Different keys are split by "," and
then weight associated with key is split by ":".

<colgroup><col width="214px"><col></colgroup>

Args

`key`

A string represents a key, or a string of multiple keys, split by ",",
and weighted by the weights split by ":". For example, key =
'softmax_loss:0.9,sigmoid_cross_entropy_loss:0.1'.

<colgroup><col width="214px"><col></colgroup>

Returns

A dict from keys to weights.

repository: tensorflow/ranking

repo_name: tensorflow/ranking


text:
# Sublime Renpy

Sublime Renpy is an extension for Sublime Text 3 which provides:

Syntax highlighting

Auto-completions

Auto-indentation

Auto tab replacement

Method snippets

which cater for Renpy as an extension to Python.

Renpy is a Visual Novel development tool, available from: http://www.renpy.org/

repository: koroshiya/Sublime-Renpy

gha_license_id: NOASSERTION

repo_name: koroshiya/Sublime-Renpy


text:
# Secrets manager parser
AWS Secrets manager parser module to handle secrets in different formats to reuse it in several AWS services.

### Warnings

- The AWS Secrets manager should be exists-

### Main features:

1. Return a list of maps ready to use it and integrate with ECS Task environments
1. Return a string of secrets
1. Return secrets as map.

#### TODO
- Improve readme.


text:
# Containers

Optimization Factors on why use containers

- Speed

- Consistency

- Governance

- Security

### Building a Container

```dockerfile
FROM golang
LABEL<EMAIL_ADDRESS>WORKDIR /workspace
COPY . .
RUN go install
ENTRYPOINT ['hello']
CMD ['world']
```

ENTRYPOINT AND CMD are always use to run application. if ENTRYPOINT is not used CMD can do the same otherwise CMD provides argument to ENTRYPOINT. In this case, CMD provide 'world' to ENTRYPOINT 'hello'

### Dockerignore

Docker **build** is done by the docker-daemon. Ignoring some files will reduce sending unnecessary to docker-daemon

This can be verified by using the grep command

```shell
docker build -t heptio hleo-img | grep sending
```

Add the names unecessary files to ignore in .dockerignore file

```dockerfile
.dockerignore
```

### Graceful Shutdown

Using Control+C to stop container will caused the system to send SIGTERM to the parent process. Using ENTRYPOINT [''sh'', "-c", "Hello \"${0} \${*}\""] in the dockerfile will cause the shell to be the parent process and consequently will not get a graceful shutdown.

Work Around

Include `exec`	in front of hello

ENTRYPOINT ["sh", "-c", "exec hello \"${0} \${*} ""]

verify this with the `ps` command, the hello will have the pid of 1.

```shell
ps
```

For Specialised Applications that does not trap the signal use the tini

tini is the backward spelling of init. Is the specialised purosed build program to be pid 1.

### Use the Flag to specify tini

```shell
docker run --init -e TINI_KILL_PROCESS_GROUP=1
```

 ### For Kubernetes

```dockerfile
FROM golang
LABEL<EMAIL_ADDRESS>WORKDIR /workspace
COPY . .
RUN go install
RUN apt-get update
RUN apt-get install tini
ENTRYPOINT ["tini", "-g", "--", "sh", "-c", "hello \"${0} \${*}\""]
CMD ['world']
```

-g flag ensure it send the signal to the group

tini will be parent to the shell and grand parent to hello.

### Layers/Caching

Docker keeps the changes and actions of every build as layers and keep track of the event as cache. This can be viewed using history.

```shell
history helo-img
```

The command runs from top to bottom and this means any changes done at certain point will be re-evaluated. In the above dockerfile, if the source ode changes, then, an update and re-install of tini will repeated. This will cause more memory usage and overhead, a waste of resources.

The dockerfile can be rewritten as this

```dockerfile
FROM golang
LABEL<EMAIL_ADDRESS>WORKDIR /workspace
RUN apt-get update && apt-get install -y --no-install-recommends tini=0.18* && rm -rf /var/lib/opt/lists/*
COPY go.mod go.sum ./
RUN go mod download -json
COPY hello-go .
RUN ago install
ENTRYPOINT ["tini", "-g", "--", "sh", "-c", "hello \"${0} \${*}\""]
CMD ['world']
```

```shell
docker build . -t green --no-cache
```

 With the new dockerfile, if the source code is modified, the build process will start from COPY command and skip the previous.

### Runtime, Image Size and Inspect

Check the id of the container

```shell
docker run --rm --entrypoint /bin/sh hello-img -c "id"
```

The trade-off of having root user privilege in application image is that we are giving the elevated access should the container be compromised.

To solve this issue, define the USER with uid before building the container.

```dockerfile
FROM golang
LABEL<EMAIL_ADDRESS>WORKDIR /workspace
RUN apt-get update && apt-get install -y --no-install-recommends tini=0.18* && rm -rf /var/lib/opt/lists/*
COPY go.mod go.sum ./
RUN go mod download -json
COPY hello-go .
RUN ago install
USER 1001
ENTRYPOINT ["tini", "-g", "--", "sh", "-c", "hello \"${0} \${*}\""]
CMD ['world']
```

Build the image and verify the user

```shell
docker run --rm --entrypiont /bin/sh helo-img -c "id"
```

### Image Sizing

Build Time and Run Time are to be considered to image sizing.

```dockerfile
FROM golang AS build
LABEL<EMAIL_ADDRESS>WORKDIR /workspace
COPY go.mod go.sum ./
RUN go mod download -json
COPY hello-go .
RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 \ go build -a -installsufix cgo -o hello

FROM scratch
COPY --from=build /workspace/hello/
USER 1001
ENTRYPOINT ["hello"]
CMD ['world']
```

 The dockerfile is separated into two the build image and the run time. There is a performance trade-off because `scratch` does not add OS, utilities and therefore makes it difficult to debug.

### Inspect

```shell
docker inspect helo-img

docker inspect helo-img -f '{{json .}}' | jq keys

docker inspect helo-img -f '{{json .Config}}' | jq keys # this gets only the config section
```

### Inspect Image Layers with dive

```shell
dive hel0-img
```

**dive** is a powerful tool that allows you to toggle between each layers and displayed the changes.

the container id can be used also

```shell
dive container_id
```

Tab key can be used to navigate to right hand side to view the changes and on the left the layers. Navigate to right and Ctrl+u to view the changes and used the Tab to navigate to left, scroll through each layers to view changes.

### JIB - Java Application

Jib is an Open Source tool developed by Google in 2018 for packaging Java application into containers. It eliminate the complexity to manage docker images. Jib only delas with the run time image and lets maven takes care of the build image.

Benefits of Jib

Simple

- Does not require a Dockerfile
- Does not require having Docker Daemon or Docker CLI installed
- Integrated with Maven and Gradle via plugin.

Fast

- Optimizes for build speed (leverages layers in docker images).
- Optimizes for application startup.

Reproducible

- Same app + same build metadata :arrow_right: Identitical image every time.

**Jib on Maven**

Does not require Docker Daemon or CLI

```shell
# default image name is artifactid:$version

mvn compile com.google.cloud.tools:jib-maven-plugin:2.2.0:build -Dimages=$REG/$REPO/$IMG:$TAG
```

Require Docker Daemon or CLI

```shell
# default image name is artifactid:$version

mvn compile com.google.cloud.tools:jib-maven-plugin:2.2.0:dockerBuild [-Dimages=$IMG:$TAG]
```

Build as Tar

```shell
# default image name is artifactid:$version

mvn compile com.google.cloud.tools:jib-maven-plugin:2.2.0:buildTar

docker load --input target/jib-image.tar
```

Add Plugin to pom file

```xml
<plugin>
	<groupId>com.google.cloud.tools</groupId>
	<artifact>Id:jib-maven-plugins</artifact>
	<version>2.2.0</version>
	<configuration>
		<to>
			<image>$REG/$REPO/$IMG:$TAG</image>
		</to>
	</configuration>
</plugin>
```

```shell
mvn complie jb:build
```

```shell
mvn compile jib:dockerBuild
```

```shell
mvn compile jib:buildTar
```

To have a shell using Jib, introduce the debug in pom.xml

```xml
<plugin>
	<groupId>com.google.cloud.tools</groupId>
	<artifact>Id:jib-maven-plugins</artifact>
	<version>2.2.0</version>
	<configuration>
		<from>
			<image>gcr.io/distroless/java:debug</image>
		</from>
	</configuration>
</plugin>
```

```shel
docker run --entrypoint /busy/box/sh image_name
```

### Buildpacks

Buildpacks has a cli utility that can be used to build the container image. To install Buildpacks follow the documentation [here](https://buildpacks.io/docs/tools/pack/)

"Pack is a tool maintained by the Cloud Native Buildpacks project to support the use of buildpacks.

It enables the following functionality:

1. [`build`](https://buildpacks.io/docs/concepts/operations/build/) an application using buildpacks.
2. [`rebase`](https://buildpacks.io/docs/concepts/operations/rebase/) application images created using buildpacks.
3. Creation of various [components](https://buildpacks.io/docs/concepts/components/) used within the ecosystem.

Pack works as both a [Command Line Interface (CLI)](https://buildpacks.io/docs/tools/pack/#pack-cli) and a [Go library](https://buildpacks.io/docs/tools/pack/#go-library)." from the Buildpacks.io web page

```shell
sudo add-apt-repository ppa:cncf-buildpacks/pack-cli
sudo apt-get update
sudo apt-get install pack-cli
```

using brew to install pack

```shell
brew install buildpacks/tap/pack
```

It also has a container build tool on dockerhub

- `buildpacksio/pack:latest`

```
docker run \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v $PWD:/workspace -w /workspace \
  buildpacksio/pack build <my-image> --builder <builder-image>
```

using Github Installation

```shell
(curl -sSL "https://github.com/buildpacks/pack/releases/download/v0.15.1/pack-v0.15.1-linux.tgz" | sudo tar -C /usr/local/bin/ --no-same-owner -xzv pack)
```

 Go Library Installation

```shell
go get -u github.com/buildpacks/pack
```

go get -u github.com/buildpacks/pack

**Pack Build**

In the working directory, set the base image required to build the container

```shell
pack set-default-builder gcr.io/paketo-buildpacks/builder:base
```

To build a image, the command follows as `pack build name_image`

```shell
pack build go-img
```

To inspect image

```shell
pack inspect-image go-img
```

**The User**

Paketo set the user to non-root-user as a default.  An advantage over docker build. Its also worth mentioning that the Buildpacks image can be build exactly the same from any part of the world using same source code.

inspect the user id

```shell
docker run --rm --entrypoint /bin/sh go-img -c "id"
```

**Inspect The Builder**

```shell
pack inspect builder
```

**Patching**

To patch an Os after a release is published, this can  be done using the YAML file with the `pack rebase` command.

```shell
pack rebase go-image --run-image gcr.io/paketo-buildpacks/builder/run:0.0.17-base-crb
```

Check the images and you find there is a new image created

```shell
docker images
```

Inspect the image corresponding to the new file system

```shell
catd <(docker inspect image_id) <(docker inspect go-image) | tail -n 20
```

**Custom BuildPack**

```
pack build go-img --buildpack from-builder --buildpack directory
```

### Spring Boot

Sping Boot version 2.33.0 has cloud native support for Java. Spring Boot uses Paketo by default and uses the artifact ID and Version to name the image.

```shell
./mvnw spring-boot:build-image -DskipTests
```

```shell
pack inspect-image hello-java:1.0.0 --bom | jq '.local[].name' -r
pack inspect-image hello-java:1.0.0 --bom | jq '.local[] select(.name==dependecies")' -r
```

### Kpack

Kpack operates as a service in kubernetes and can be configured declaratively.

```shell
kubectl api-resources --api-group build.pivotal.io
```

kpack/builder.yaml

```yaml
apiVersion: build.pivotal.io/v1alpha1
kind: Builder
metadata:
	name: paketo-builder
spec:
	image: gcr.io/paketo-buildpacks/builder:base
```

kpack/image.yaml

```yaml
apiVersion: build.pivotal.io/v1alpha1
kind: Image
metadata:
	name: hello-go
spect:
	builder:
		name: paketo-builder
		kind: Builder
	serviceAccount: kpack-service-account
	cacheSize: "1.5Gi"
	source:
	 	git:
	 		url: https://github.om/cibrerkleid/hello-go
	 		revision: master
	 	subPath: src
	 tag: ciberkleid/hello-go:latest
```

Trigger on git source will cause the kpack to build the image

use the kubectl describe command to view the image

```shell
kubectl describe image hello-go
```

```shell
kubectl get build #LAST_BUILD -o json | jq .metadata.annotations
```

kpack logs

```shell
logs -namespace kpack-builds -image hello-go
```

repository: eedygreen/kubeacademyLearning

branch_name: refs/heads/main

repo_name: eedygreen/kubeacademyLearning


text:
# s3-utilities
Utility tool for storing and downloading pandas DataFrames to and from AWS S3.

## Create Connection Client
```python
from s3utils import S3Client

# create a client by explicitly passing auth. details.
client = S3Client(aws_access_key_id, aws_secret_access_key)

# create client and using locally stored auth profile (recommended).
https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html
client = S3Client.using_awsprofile(profile_name='s3')
```

## Upload to S3
```python

# upload gzipped dataframe
df = pd.DataFrame(np.random.randint(0, 100, size=(100, 4)), columns=list('ABCD'))
client.upload_dataframe(df, "gvt-test-bucket", "test-file")

# upload binary file or buffer
with open(filepath, 'rb') as f_hnd:
    success = client.upload_fileobj(f_hnd, bucket="gvt-test-bucket", key="test-bin-file")
```

## Download from S3
```python

# download gzipped dataframe
resp_df = client.download_dataframe("gvt-test-bucket", "test-file")

# download to binary file handle or byte buffer (io.BytesIO)
with open(filepath, 'wb+') as f_hnd:
    success = client.download_fileobj('gvt-test-bucket', 'test-bin-file', f_hnd)

```


text:
# my-passwordless-ssh-cluster

To set up a passwordless SSH for communication between nodes in a cluster.
Init your master node with the script first, and then each time you init a new slave node, the script will do the work to set passwordless ssh communication for all the servers.

### Intro:

The scripts have been tested with vagrant, on ubuntu 14.04.
- 1. vagrant up your master node, with a shell provision points to hd-master.sh
- 2. vagrant up the other slave nodes, with a shell provision points to hd-slave.sh (The CURRENT_NODE_ADDRESS param needs to be updated accordingly)

### After processing:
- The password of linux user vagrant will be set to 'a', on both master and slave nodes.
- *Known Issue*: You must manually type in the password 'a' when you try to 'vagrant ssh' the slave node. This's because the original authorized_keys file has been replaced on slave nodes.

repository: fanyangxi/my-passwordless-ssh-cluster

repo_name: fanyangxi/my-passwordless-ssh-cluster


text:
# app
This is a simple app that uses socket io + angularjs v1.2.32.

The client sends a message to the server and the server broadcasts this message back.

![Screenshot](prints/chat-001.png)

### TODO:
- [x] Create a new project on Github.
- [x] Right now it is only showing the last message. We need it to list all the messages sent in a session. It could be a list `ul > li`.
- [x] Add the date and time for each message.
- [x] Add a validation, don't let the user hit send if there nothing to be sent.
- [x] The current implementation it is only broadcasting the message to the sender, make it broadcast the message to all the users that have the app opened.
- [x] Make it looks like chat app.

#### Plus:
- [x] Allow the users to have a nickname.
- [x] Allow the users to enter a room name.
- [x] Make it pretty.

### TODO(update):
1) [ ] Fix close button icon size.
2) [ ] Fix messages animation:
        When the user clicks the close icon all messages animate. Prevent them from doing so.
3) [ ] Refactor io.services.
4) [ ] Allow users to send public messages to others users in the same room. Now they can only send messages to everyone or private messages to another user.
    The message should appear like this:
    Mike to Brian : Hi, Brian.

    When a user choose to talk privatly to another user a new view(room) show be created.
5) [ ] Allow the user to create a new room. Right now there's only two rooms.
6) [ ] For a distante future: Allow the user to use or upload an avatar.

## Running

You will need `node` and `npm`.

### server
it will use the port 3696
*run:*
`cd server`
`npm install`

### client
it will use the port 8012
*run:*
`cd app`
`npm install`

### Now run:
`npm start` in the root folder and open http://localhost:8012

license: Unlicense

repository: ItamarSerafim/ngchat

repo_name: ItamarSerafim/ngchat


text:
* Working: Yes
* Interesting: So So
* Progress: On Hold
* Purpose: Experiment

yac [(by erikecoologic)](https://github.com/ecoologic)
===

Yet another chat...

## Libraries

* Angular.js 1.3
* Firebase 1.0
* Bootstrap 3.1
* LoDash 2.4

## Open-source Contribution

Please feel free to send a pull request, fork or get in touch.

## Run the server (from `app/`)

    python -m SimpleHTTPServer # => localhost:8000
    # or any other http server like middleman

## Working features

See the [`CHANGELOG.md`](/CHANGELOG.md)

### Todo

* Current room at the bottom
* Animation for latest message
* Unsubscribe from a room
* Private rooms
* User autocomplete in new message http://ngmodules.org/modules/ngAutocomplete
* Smiles autocomplete in new message
* `.new-message { position: fix }`
* Footer with credits and help
* Better icons
* Limit fetched messages
* Improve Firebase security roles
* Bower
* Linemanjs

#### Ui-ideas

* append new text to previous message unless other user interrupt
* no delete/edit except last message
* cli for room navigation
  - `/-old_room # => UNSUBSCRIBE from room_x (default will be subscribed)`

repository: ecoologic/yac

repo_name: ecoologic/yac


text:
Mongo Decorators and Modules

## Description

This is a MayaJS library that deals with Mongodb drivers. It uses `mongoose` to connect to any mongodb database. It also use mongoose Schema and Model for its model creation.

## Decorators

### Models

> Creates a model intance based on the name passed on the parameter.

MayaJS collect and store all the models defined on the `@Controller` decorators to a single object. Everytime the `@Models` decorator is attached to a variable it replace its value with a model instance. This model instance is based on [mongoose model](https://mongoosejs.com/docs/api/model.html). All of mongoose functionality is available for this model instance.

#### Pseudo Code

```javascript
   @Models(model_name:string) varaiable_name;
```

#### Sample Code

```javascript
   @Models("sample") model;
```

## Modules

### Mongo

> A wrapper for mongoose that MayaJS use to connect to MongoDB.

Mongo accepts an object settings that will set the connection for MongoDB. MayaJS will automatically connect to the specified settings whenever the server starts. It will also set the models using the models function. It typically used inside the `@App` decorator on the options paramater.

#### Options

```javascript
{
  connectionString: string; // Connection string
  options?: ConnectionOptions; // Mongoose connect options OPTIONAL
  schemas?: SchemaObject; // Mongoose schema object OPTIONAL
}
```

> **NOTE:** See full documentation of [ConnectionOptions here.](https://mongoosejs.com/docs/connections.html#options)

#### Sample Code

```javascript
@App({
  database: Mongo({
    connectionString: "your-connection-string-here",
    options: {}, // Define Mongodb options
    schemas: [], // Add mongoose schema here
  }),
})
export class AppModule {}
```

## Collaborating

See collaborating guides [here.](https://github.com/mayajs/maya/blob/master/COLLABORATOR_GUIDE.md)

## People

Author and maintainer [Mac Ignacio](https://github.com/Mackignacio)

## License

[MIT](https://github.com/mayajs/maya/blob/master/LICENSE)

repository: applekiwiejuice/mongo

repo_name: applekiwiejuice/mongo


text:
# sample deploy app using [onnxruntime](https://github.com/microsoft/onnxruntime) #
***

This sample uses Cpp api of onnxruntime.

## Dependencies ##
***

- [onnxruntime](https://github.com/microsoft/onnxruntime)
  * tested with v1.10.0
  * to build onnxruntime from source you need cmake>=3.18
  * you can build from source with the [build script](https://github.com/microsoft/onnxruntime/blob/master/build.sh)
  * here is the sample procedure to build cpu onnxruntime
  ```bash
    readonly ONNXRUNTIME_VERSION="v1.10.0"
    git clone --recursive -b ${ONNXRUNTIME_VERSION} https://github.com/Microsoft/onnxruntime
    ./build.sh --config RelWithDebInfo --build_shared_lib --skip_tests --parallel `nproc`
    cd build/Linux/RelWithDebInfo
    make install
    ```

- opencv
```bash
sudo apt-get install libopencv-dev
```

## How to Build ##
***
```bash
mkdir build && cd build && cmake ../ && make -j`nproc`
```

## How to Run ##
***

- Download test images
```bash
wget https://paddleseg.bj.bcebos.com/dygraph/demo/cityscapes_demo.png
```

- Export PaddleSeg Model to onnx format
  * [export PaddleSeg model](https://github.com/PaddlePaddle/PaddleSeg/blob/develop/docs/model_export.md)
  * convert exported model to onnx format with [Paddle2ONNX](https://github.com/PaddlePaddle/Paddle2ONNX)

- You can download the bisenetv2 onnx model for this demo directly from the following url:
```bash
wget https://github.com/PaddlePaddle/PaddleSeg/files/7918707/bisenetv2_cityscapes.zip && unzip bisenetv2_cityscapes.zip
```

- Run app

```bash
./build/onnxruntime_cpp_inference_demo_app /path/to/test/image /path/to/onnx/model
```

The result will be saved as *out_img.jpg*

repository: PaddlePaddle/PaddleSeg

repo_name: PaddlePaddle/PaddleSeg


text:
# umireon/texlive-ja

The Docker image of TeX Live for Japanese documents

## How to install

```bash
docker pull umireon/texlive-ja
```

## How to use

```bash
% docker run -it -v $(pwd):/workdir umireon/texlive-ja
% latexmk main.tex
```

---

Forked back from https://github.com/Paperist/texlive-ja.

Originated in https://github.com/umireon/docker-texci.

repository: umireon/texlive-ja-docker

gha_language: TeX

repo_name: umireon/texlive-ja-docker


text:
---
layout: project
type: project
image: images/ManoaBooks.jpg
title: Manoa Cart
permalink: projects/ManoaCart
# All dates must be YYYY-MM-DD format!
date: 2019-05-07
labels:
  - Software Engineering
  - UH Manoa Bookstore
  - Meteor
  - Galaxy
summary: Manoa Cart is a website to buy used textbooks from former students.
---
<img class="ui right floated rounded image" src="/images/ManoaCartLanding.PNG" style="max-width: 200px;" style="max-height: 400px;"/>

This project was designed for students to sell their old textbooks to those that need to take the class.


text:
+++
title = "Exploring the Relationship between Urban Forms and CO2 Emissions in 104 Chinese Cities"
date = 2017-12-15

# Authors. Comma separated list, e.g. `["Bob Smith", "David Jones"]`.
authors = ["**Mingshu Wang**", "Marguerite Madden", "Xingjian Liu"]

# Publication type.
# Legend:
# 0 = Uncategorized
# 1 = Conference proceedings
# 2 = Journal
# 3 = Work in progress
# 4 = Technical report
# 5 = Book
# 6 = Book chapter
publication_types = ["2"]

# Publication name and optional abbreviated version.
publication = " *Journal of Urban Planning and Development*, *4*, 04017014"
publication_short = " *Journal of Urban Planning and Development*, *4*, 04017014"

# Abstract and optional shortened version.
abstract = "This study explores the empirical relationship between city-level urban forms and CO2 emissions in 104 Chinese prefectural-level cities. Although the analytical focus is on polycentric urban forms, the analysis has also accounted for population size and land use compactness. CO2 emissions data are aggregated from the Fossil Fuel Data Assimilation System (FFDASv2) data portal. The analysis identifies substantial economies of scale in CO2 with respect to total population. Further, despite a substantial wealth effect on CO2 emissions, cities with more centralized and compact urban forms are associated with lesser emissions, ceteris paribus. Whereas existing analyses of CO2 emissions in Chinese cities have often been limited to a handful of provincial capitals, the analysis covers a larger sample of cities. The paper concludes with spatial planning policy implications."

abstract_short = "This study explores the empirical relationship between city-level urban forms and CO2 emissions in 104 Chinese prefectural-level cities. Although the analytical focus is on polycentric urban forms, the analysis has also accounted for population size and land use compactness."

# Featured image thumbnail (optional)
image_preview = ""

# Is this a selected publication? (true/false)
selected = true

# Projects (optional).
#   Associate this publication with one or more of your projects.
#   Simply enter the filename (excluding '.md') of your project file in `content/project/`.

projects = []

# Links (optional).
url_source = "https://ascelibrary.org/doi/abs/10.1061/%28ASCE%29UP.1943-5444.0000400"
#url_pdf = "https://outlookuga-my.sharepoint.com/:b:/g/personal/mswang_uga_edu/Edok_KnRpdtLjmI_riYN9g4BekkNpwco2_-476u5qSGeIQ"
#url_preprint = "#"
#url_code = "#"
#url_dataset = "#"
#url_project = "#"
#url_slides = "#"
#url_video = "#"
#url_poster = "#"
#url_source = "#"

# Custom links (optional).
#   Uncomment line below to enable. For multiple links, use the form `[{...}, {...}, {...}]`.
# url_custom = [{name = "Custom Link", url = "http://example.org"}]

# Does the content use math formatting?
math = true

# Does the content use source code highlighting?
highlight = true

# Featured image
# Place your image in the `static/img/` folder and reference its filename below, e.g. `image = "example.jpg"`.
[header]
#image = "headers/JTG2017.jpg"
#caption = "Bike-sharing systems (BSSs) in US urban areas, 2005–2014."

+++


text:
##### CONTAINER

Create a new container

```
create(
    int <container-preset-id>,
    string <title>,
    int <folder-id>,
    HashMap <hash-map>
): ResourceInformation
```

Retrieve the details of a container

```
getDetailById(int <container-id>): HashMap
```

Update a container

```
update(int <container-id>, HashMap <hash-map>): ResourceInformation
```

Move a container to a folder

```
move(int <container-id>, int <folder-id>): ResourceInformation
```

Copy a container to a folder

```
copy(int <container-id>, int <folder-id>): ResourceInformation
```

Delete a container

```
delete(int <container-id>): bool
```

Retrieve all containers of a mandator

```
getListByMandatorId(int <mandator-id>): ResourceInformation[]
```

Retrieve all containers in a folder

```
getByFolderId(int <folder-id>): ResourceInformation[]
```

Retrieve a container by id

```
getById(int <container-id>): ResourceInformation
```

Retrieve all related objects by type id

```
getByTypeId(int <type-id>, int <mandator-id>): ResourceInformation[]
```

Retrieve the default folder for containers

```
getDefaultFolderByMandatorId(int <mandator-id>): FolderInformation
```

Retrieve all related object type ids

```
getTypeIds(): ResourceTypeInformation[]
```

Retrieve a container by its external id

```
getByExternalId(string <external-id>): ResourceInformation
```

Get object specific details of a container

```
getDetailsById(int <container-id>): ContainerDetail
```

Retrieve all containers by their container type id

```
getByContainerTypeId(int <container-type-id>): ResourceInformation[]
```


text:
Once SLAM node is successfully up and running, TurtleBot3 will be exploring unknown area of the map using teleoperation. It is important to avoid vigorous movements such as changing the linear and angular speed too quickly. When building a map using the TurtleBot3, it is a good practice to scan every corner of the map.

1. Open a new terminal and run the teleoperation node from the PC.
  Please use the proper keyword among `burger`, `waffle`, `waffle_pi` for the `TURTLEBOT3_MODEL` parameter.
  ```bash
> set TURTLEBOT3_MODEL=waffle
> roslaunch turtlebot3_teleop turtlebot3_teleop_key.launch

    Control Your TurtleBot3!
    ---------------------------
    Moving around:
           w
      a    s    d
           x

    w/x : increase/decrease linear velocity
    a/d : increase/decrease angular velocity
    space key, s : force stop

    CTRL-C to quit
  ```

2. Start exploring and drawing the map.
  ![](/assets/images/platform/turtlebot3/slam/slam_running_for_mapping.png)

repository: ROBOTIS-GIT/emanual

repo_name: ROBOTIS-GIT/emanual


text:
Live Demo

Lightweight version of Vitesse

## Dropped Features

- ~~i18n~~
- ~~Layouts~~
- ~~SSG~~
- ~~PWA~~
- ~~Markdown~~

## Features

- ⚡ [Vue 3](https://github.com/vuejs/vue-next), [Vite 2](https://github.com/vitejs/vite), [pnpm](https://pnpm.js.org/), [ESBuild](https://github.com/evanw/esbuild) - born with fastness

- 🗂 [File based routing](./src/pages)

- 📦 [Components auto importing](./src/components)

- 🎨 [Windi CSS](https://github.com/windicss/windicss) - next generation utility-first CSS framework

- 😃 [Use icons from any icon sets, with no compromise](./src/components)

- 🔥 Use the [new `<script setup>` style](https://github.com/vuejs/rfcs/pull/227)

- 🦾 TypeScript, of course

- ☁ Deploy on Netlify, zero-config

See [Vitesse](https://github.com/antfu/vitesse) for full featureset.

## Pre-packed

### UI Frameworks

- [Windi CSS](https://github.com/windicss/windicss) (On-demand [TailwindCSS](https://tailwindcss.com/)) - lighter and faster, with a bunch of additional features!

### Icons

- [Iconify](https://iconify.design) - use icons from any icon sets [🔍Icônes](https://icones.netlify.app/)
- [`vite-plugin-icons`](https://github.com/antfu/vite-plugin-icons) - icons as Vue components

### Plugins

- [Vue Router](https://github.com/vuejs/vue-router)
  - [`vite-plugin-pages`](https://github.com/hannoeru/vite-plugin-pages) - file system based routing
- [`vite-plugin-components`](https://github.com/antfu/vite-plugin-components) - components auto import
- [`vite-plugin-windicss`](https://github.com/antfu/vite-plugin-windicss) - WindiCSS support
- [VueUse](https://github.com/antfu/vueuse) - collection of useful composition APIs
- [`@vueuse/head`](https://github.com/vueuse/head) - manipulate document head reactively
- [`vue-global-api`](https://github.com/antfu/vue-global-api) - Use Vue Composition API globally

## Try it now!

### GitHub Template

[Create a repo from this template on GitHub](https://github.com/antfu/vitesse-lite/generate).

### Clone to local

If you prefer to do it manually with the cleaner git history

```bash
npx degit antfu/vitesse-lite my-vitesse-app
cd my-vitesse-app
pnpm i # If you don't have pnpm installed, run: npm install -g pnpm
```

repository: egahika-sandbox/firebase-vite

repo_name: egahika-sandbox/firebase-vite


text:
---
title: Low Latency Queuing Control in Extendable Mobile Ad-hoc Network Emulator (EMANE)

summary: Designed and tested a novel low-latency network scheduling module for various queueing policies using C/C++ under Linux Ubuntu system, and evaluated the algorithm in WAN under Common Open Research Emulator (CORE)
tags:
- Computing Network
date: "2020-09-15T00:00:00Z"

# Optional external URL for project (replaces project detail page).
external_link: ""

links:
url_code: "https://github.com/szl0144/EMANE_CORE"
url_pdf: ""
url_slides: ""
url_video: ""

---

A variation packets delay which is also called packet jitter causes packet loss and delay. When jitter happens to stream video, users suffer an annoying freezes which results in user unpleasant. The solution for reducing jitter probability is a low latency low-complexity scheduling policy in queuing system: the Earliest Due Date first (EDD) policy. To evaluate the performance of EDD in a real-world wireless network system. We implement EDD algorithms on Extendable Mobile Ad-hoc Network Emulator (EMANE) to take virtual field tests. In this paper, we present the design and implementation of a low-complexity queue scheduling module in both single-hop multi-server systems using C/C++. We also show an efficient debug method in EMANE development. Our emulation results demonstrate the EDD policy achieves over 1000x reduction in jitter probability compared to the commonly used FCFS policy.


text:
iScrollDnD
==========

iScrollDnD is a Javascript library to simulate an iScrollView on the iPad or Android with Drag'n'Drop capabilities

Demo
====

http://vimeo.com/16146688

## License
iScrollDnD has been developed by Matteo Spinelli for Storify and is distributed under MIT license

repository: IonianWeddingsLimited/website

repo_name: IonianWeddingsLimited/website


text:
# Skywalker

Walks a directory or a file and optionally applies transformations on the tree's members.
There are other modules that do the same, I didn't like them, rolled my own.

_Can't believe skywalker was not already in use on npmjs._

-----
## Install
```bash
	npm install skywalker
```

----
## Features

 - Easy to use
 - Callbacks or evented style
 - Directory sizes
 - Supports limited depth, regex filtering, glob matching, mime-type filtering, extension filtering
 - Easy as hell to write plugins for

-----
## Usage

```js
	var Tree = require('skywalker');

	Tree('~/some_dir')
		.ignoreDotFiles()
		.ignore(/(^|\/)_.*?$/g) //ignores files that begin with "_"
		.filter(/something/g,function(next,done){
			console.log('runs for each file or directory that match "something"');
			next()
		})
		.filter(/(^|\/)_.*?$/g,function(next,done){
			console.log('rejects all files or directories that begin with "_"',this._.path);
			done(null,false);
		})
		.extensionFilter('json',function(next,done){
			console.log('runs for each file that has a json extension');
			var file = this;
			require('fs').readFile(this._.path,{encoding:'utf8'},function(err,contents){
				if(err){
					file._.error = err;
					return next();
				}
				file._.contents = contents;
				try{
					file.data = JSON.parse(contents);
				}catch(err){
					file._.error = err;
				}
				next();
			})
		})
		.on('file',function(file){console.log('file event:',file._.path);})
		.on('directory',function(file){console.log('directory event:',file._.path);})
		.on('done',function(file){console.log('-----------------------');})
		.emitErrors(true)
		.on('error',function(err){console.log('ERROR',err);})
		.start(function(err,file){
			if(err){return console.log(err);}
			for(var n in file){
				console.log(file[n]);
			}
			//or
			var children = file._.children;
			for(var i=0;i<children.length;i++){
				console.log(children[i]._.name);
			}
		})
```

If for some reason you want to set the root directory name later (not at instantiation), do that:

```js
	Tree()
		.file('path_to_file')
		//other things
		.start(callback)

```

By default, skywalker does not emit errors, as it is expected that they will be handled in callbacks.
However, if you prefer event-style error handling, do the following:

```js
	Tree(dir)
	.emitError(true)
	.on('error',function(err){
		console.log('error',err);
	})
	.start(func);
```

-----
## Files Properties

All properties (name, path, etc) are stored on a property named "_".
The following properties are to be found:

 - `file._.path`  full path to the file
 - `file._.dirname`  parent dir of the file
 - `file._.filename`  filename of the file, including extension
 - `file._.extension`  extension, without the dot, and in lowercase
 - `file._.name`  filename without extension
 - `file._.children`  only for directories: an array of children
 - `file._.parents`  an array of parents (backref to the parents)
 - `file._.contents`  empty, fill it with a string if your own callbacks
 - `file._.mime`  mimetype, for example 'text/plain'
 - `file._.mime.type`  for example 'text'
 - `file._.mime.subType` for example, 'plain'
 - and all `stats` properties, which are:
 	+ `dev`
 	+ `mode`
 	+ `nlink`
 	+ `uid`
 	+ `gid`
 	+ `rdev`
 	+ `blksize`
 	+ `ino`
 	+ `size` works for directories too
 	+ `blocks`
 	+ `atime` converted to a unix timestamp
 	+ `mtime` converted to a unix timestamp
 	+ `ctime` converted to a unix timestamp

Plugins may add properties to this object (see below).

If you have, in your path, a file or folder named "_", then the properties of its parent will be overwritten.
In that case, you have two options:
1 - Change the default namespace:
```js
	Tree.propertiesPropertyKey('_somethingsafe_');
	// later...
	console.log(file._somethingsafe_.path)
```
2 - use the 'safe' namespace:
```js
	console.log(file.__________.path);
	// Yes, that's 10 "_".

The default toString() function outputs the file's path, but if you set the `contents` property of the file...

```js
	file._.contents = 'abcde';
```

...Then this is what toString() will output.

To detect mimetypes, skywalker uses [node-mime](https://github.com/broofa/node-mime). It is made available on the `Tree.mime` namespace

```js
	//define a new mime-type:
	Tree.mime.define({
		'text/jade':['jade']
	})
```

------
## Filters
There are several available filters, they all have the same signature:
`filterFunction(regex|glob|null,func)`

- `regex or glob` is either a regex or a string. If nothing is provided, the filter will match every file and directory
- `func` is a function with signature `callback(next,done)`. Next() processes the next file, and done() interrupts the current directory processing. You can call done(err) to output an error.

-----
## Selectors
Selectors run *after* the tree has been parsed and allow for further filtering.

```js
	var Tree = require('skywalker');
	var db = Tree.db;
	Tree(__dirname)
		.ignoreDotFiles()
		.selectors('F & size > 6100')
		.start(function(err,file){
			var c = file._.children;
			for(var n in c){console.log(c[n]._.path)}
		})
```

A selector presents itself as such:
`property operator value`

- `property` is any property of the file, found on the `_` object. That is any 'native' property, or any property added by a plugin
- `operator` is one of the operators below
- `value` is the value compared to. some operators don't require a value

You can chain selectors with '&'.
Available selectors are:

- Selectors with properties:
	- `GREATER_THAN : '>'` example: `size > 6100`
	- `LOWER_THAN: '<'` example: `atime <<PHONE_NUMBER>`
	- `GREATER_OR_EQUAL: '>='`
	- `LOWER_OR_EQUAL: '<='`
	- `EQUAL: '=='`
	- `EQUAL_STRICT: '==='`
	- `MATCHES: '#'` example: `path # node_modules`
- Selectors that require a value only:
	- `EXTENSION: '.'` example `. jpg` (does not require a property)
	- `PATH: '/'` example `/ node_modules` (similar to the `matches` example above, but globbing is allowed)
	- `MIMETYPE: '@'` example: `@ text/javascript`
- Selectors that require an operator only:
	- `ISDIR: 'D'`
	- `ISFILE:'F'`

-----
## Plugins

Skywalker ships with a few examples plugins (not loaded, copy-paste them where you need them). They are:

- checksum: outputs a checksum string in a property called `checksum`. Needs the `checksum` module.
- images: outputs size (width,height), imageMode (landscape, portrait, square) and ratio (1.xxx) to the "_" property of images. Needs the `image-size` module.
- json: parses json files. Sets the raw data on the "\_.contents" and the parsed data on "\_.data"
- markdown: parses markdown files. Sets the raw data on "\_.contents" and the rendered content on "\_.rendered". Needs the `markdown` module.
- size: adds a human readable size property called `humanSize`. Needs the `filesize` module.
- websafe: turns file names ("my nice image.jpeg") to a string that can be used in a classname or as an id ("my_nice_image"), and sets it on the "_.safename" property

add a plugin by calling
`Tree(dir).plugin(require('path-to-plugin').start(...`

**Be careful, order of filters and plugins does matter**

-----
## More Info & Examples
Check out the tests.
* install moka and chai:
`npm install -g mocha chai`
* run the tests
`cd skywalker && mocha`

----
## License
MIT

repository: Xananax/skywalker-extended

repo_name: Xananax/skywalker-extended


text:
# MRv2 UI

## Overview

"MRv2 UI" is a web interface of job history of Hadoop MapReduce v2(MRv2) and works on Apache Tomcat.
MRv2 is run on Hadoop YARN environment. And MRv2 UI uses the information of Hadoop YARN environment. MRv2 UI aims to run in the same Tomcat as Tez UI.

MRv2 UI provides the following information.

  * MapReduce v2 job list
  * MapReduce v2 job summary
  * Task list of MapReduce v2 job

## Requirement

* Java 1.7+
* Apache Tomcat 8+
* Apache Maven 3+

* Running Hadoop YARN TimelineServer (Apache Hadoop 2.6+)

## How to build and install

  * Run "git clone" command

        $ git clone https://github.com/sinchii/mrv2-ui.git mrv2-ui

  * Run mvn command

        $ cd mrv2-ui
        $ mvn clean package

  * (if needed) Start Tomcat

        $ ${TOMCAT_HOME}/bin/catalina.sh start

  * Move mrv2-ui.war to Tomcat webapps directory

        $ cp target/mrv2-ui.war ${TOMCAT_HOME}/webapps/

  * Configure web.xml after MRv2UI application deployed by Tomcat.
  Set the address of TimelineServer to "mrv2ui.tls.http.address"

        $ vim ${TOMCAT_HOME}/webapps/mrv2-ui/web.xml

  * Access to MRv2 UI page

        http://${TOMCAT_ADDRESS}:${TOMCAT_PORT}/mrv2-ui/

# Sample images

  * [MapReduce job list](https://gist.github.com/sinchii/9572774d657a28192f97#file-mrv2ui-joblist-png)
  * [MapReduce job information](https://gist.github.com/sinchii/9572774d657a28192f97#file-mrv2ui-job-png)
  * [MapReduce task information](https://gist.github.com/sinchii/9572774d657a28192f97#file-mrv2ui-task-png)

# License

[Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0)

# Author

Shinchi Yamashita / @\_sinchii\_


text:
### [CVE-2020-5517](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-5517)
![](https://img.shields.io/static/v1?label=Product&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=n%2Fa&color=brighgreen)

### Description

CSRF in the /login URI in BlueOnyx 5209R allows an attacker to access the dashboard and perform scraping or other analysis.

### POC

#### Reference
No PoCs from references.

#### Github
- https://github.com/ARPSyndicate/cvemon
- https://github.com/CyberSecurityUP/My-CVEs
- https://github.com/Live-Hack-CVE/CVE-2020-5517

repository: trickest/cve

gha_language: HTML

repo_name: trickest/cve


text:
# REGEX Tutorial

## Contributers
* Chris Whalen, Github: **[CobaltFrostfish](https://github.com/CobaltFrostfish)**

## Links
* **[Repository](https://github.com/CobaltFrostfish/REGEX)**
# [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

## The project
Regular expressions or **REGEX** is a powerful toolthat is extremely useful in extracting information from any text. **REGEX** works by searching one or more matches of a specific search pattern. In this tutorial I'll dicuss the different types of unicode to search for email addresses within a specific set of code or text. So please pull up a chair with a cold beverage and lets learn about REGEX.

## Technologies applied
* REGEX
* MyBrain

## Sources
* **[Medium.com](https://medium.com/)**

repository: CobaltFrostfish/REGEX

repo_name: CobaltFrostfish/REGEX


text:
# Chamaeota sphaerospora (Peck) Kauffman, 1918 SPECIES

#### Status
SYNONYM

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
The Gilled Mushrooms of Michigan and the Great Lakes Region 534 (1918)

#### Original name
Annularia sphaerospora Peck, 1903

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Basidiomycota/Agaricomycetes/Agaricales/Pluteaceae/Pluteus/Pluteus mammillatus/ Syn. Chamaeota sphaerospora/README.md

repo_name: mdoering/backbone


text:
# Greg Kikola's dotfiles

My personal configuration files that I use on my systems which run various
GNU/Linux distributions.

# Usage

These files can be easily managed with
[GNU Stow](https://www.gnu.org/software/stow/).

The files are grouped into subdirectories. To install a particular group of
files, navigate to the base directory (the one containing this README.md
file) and run the command `stow DIRECTORY`, where `DIRECTORY` is the
subdirectory containing the files to be installed. This will create
symbolic links within your home directory that point to the files in this
git repository.

# License

Unless otherwise stated within the file, the contents of each of these
files is licensed under the
[Apache License 2.0](http://www.apache.org/licenses/LICENSE-2.0). See the
file [LICENSE.txt](LICENSE.txt) for full details.

repository: gkikola/dotfiles

repo_name: gkikola/dotfiles