text:
# Overview of meteormogul.dev

Last update: March 25, 2018

This is an app for publishing www.meteormogul.com.

As a proof of concept, the website is published as a static single-page app (static SPA) on [Netlify](https://www.netlify.com/).

A static SPA is a bundle that consists of

- one HTML file (the "single page")
- JavaScript files
- CSS files
- other assets (fonts, images, etc.)

Once the bundle has been delivered to the client, no further action by the server is necessary (that's why this approach is called "static").

Once running in the browser client, the app can provide routing and all sorts of other goodies, but doesn't need to maintain a connection to the server.

This app uses
- Meteor for the full-stack JS framework and build system,
- VueJS for the view layer,
- Vuetify for the front-end components,
- Material Design Icon Fonts for icons, and
- vue meteor tracker to allow Vue components to see Meteor reactivity.
- Meteor's markdown package so I can write content in Markdown

This repo is the app that serves a dynamic version of the website.  A separate repo, [`mogul-ssg`](https://github.com/meteor-mogul/mogul-ssg), has the code that takes any dynamic Meteor app and attempts to turn it into a static SPA.  See the docs for `mogul-ssg` to learn more about how it works.

## Application Structure

I'm not exactly following the [Meteor Guide fo Application Structure](https://guide.meteor.com/structure.html).

Here's what's in each folder:

```
.docs/                    # documentation
.meteor/                  # meteor files (packages, versions, etc.)
client/                   # code that runs on client only
  api/                    # domain logic and access to data structures
    nouns/                # objects for data structures
    verbs/                # methods for using data structures
  data/                   # data structures (articles, lists, notices)
  ui/                     # vue components (navdrawer, toolbar, content, footer)
    views/                # content views (home page, articles, notices, etc.)
    widgets/              # quickstart, menus (learn, play, create)
public/                   # other assets besides .html, .css, and .js files
  img/                    # image files
server/                   # code that runs on server only
```

## Debugging

First, get [Vue.js devtools](https://github.com/vuejs/vue-devtools).

I find Chrome to be the most dependable browser to use for development; there is a Vue.js devtools extension for Chrome.  Once you add it, you'll see it at the very right of the developer tools tabs (Elements, Console, Sources, ..., Vue).

In addition to all the help you get from this and all the regular JavaScript debugging built into Chrome, I still find it is helpful to add console logging from time to time.

So I set `MMDEBUG` in `client/debug.js`.  The `imports.js` file imports this symbol from `debug.js` and re-exports it, so all other code can just import the symbol from `imports.js`.  When `true`, `MMDEBUG` turns on the console logging debug statements I've sprinkled through the code in places that have caused me heartache.  E.g.,

```js
MMDEBUG && console.log("mmContentHome defined in home.js:", mmContentHome);
```

## Vue Components

Each Vue instance and component is defined by one `.html` file that contains its template, inside `<script type="text/x-template" id="name">`, and one `.js` file that contains its code.

Some Vue components also have a `.md.js` file that contains markdown text.

The main Vue app is defined in `client/main.js`.

Rather than registering components globablly with `Vue.component()`, I use local registration by giving each instance and component a `components` attribute.

For example, here is the definition of the main Vue instance, locally registering components for navigation drawer, toolbar, content and footer:

```js
// Create the Vue instance
var mmVue = new Vue({

    template:
    '#mm-app-template',

    components:
    {
      'mm-navdrawer': mmNavdrawer,
      'mm-toolbar': mmToolbar,
      'mm-content': mmContent,
      'mm-footer': mmFooter
    },

    // Get common data and methods
    mixins:
    [
      drawerMixin
    ]

  // We're getting fancy with the $mount API.
  // See https://vuejs.org/v2/api/#vm-mount
}).$mount('#app');
```

### Constructors versus child components

You have two choices about how to build Vue components.

For example, if you want three menus you can either define 1) a menu maker function or 2) a menu component.

#### Constructor pattern (e.g., mmMenuMaker)

This pattern might make sense if you need a small set of components and want to make your template code simple.

Create the maker function:

```js
function mmMenuMaker(menu, title, subhead, items, target) {
  this.name =
  'mm-menu-' + menu;

  this.template =
  '#mm-menu-template';

  this.data =
  function () {
    return {
      title,
      subhead,
      items,
      target
    };
  };
}
```

Create menus with the maker function:

```js
const mmMenuLearn = new mmMenuMaker('learn','Learn','Documentation',mmListDocs,'router');
```

Add the menu as a component:

```js
var mmToolbar =
{
  name: 'mm-toolbar',
  template: '#mm-toolbar-template',

  components:
  {
    'mm-menu-learn': mmMenuLearn
  },
};

```

Use the menu in a template:

```html
<mm-menu-learn></mm-menu-learn>
```

Notes about this pattern:
- Every child component gets unique name and tag
- Best for use cases where you have limited number of child components known in advance

Advantages to this pattern:
- Gives maximum flexibility to override definition of each child component.
- Component name shows up in Vue debugger
- Don't need to pass props in template

#### Child component pattern (e.g., mmMenu)

Use this pattern if you need to make many similar components.

Create the component:

```js
var mmMenu =
{
  name:
  'mm-menu',

  template:
  '#mm-menu-template',

  props:
  [
      'title',
      'subhead',
      'items',
      'target'
  ]
};
```

Use menu as a child component and set up data in parent component to pass as props to children:

```js
var mmMenus =
{
  learn:
  {
    name: 'learn',
    title: 'Learn',
    subhead: 'Documentation',
    items: mmListDocs,
    target: 'router'
  },
  play:
  {
    name: 'play',
    title: 'Play',
    subhead: 'heroku demos',
    items: mmListDemos,
    target: '_blank'
  },
  create:
  {
    name: 'create',
    title: 'Create',
    subhead: 'GitHub repos',
    items: mmListRepos,
    target: '_blank'
  }
};

var mmToolbar =
{
  name: 'mm-toolbar',
  template: '#mm-toolbar-template',

  components:
  {
    'mm-menu': mmMenu,
  },

  data:
  function() {
    return {
      menus: mmMenus
    };
  }
};
```

Use menus in a template:

```html
<v-toolbar-items v-for="menu in menus" :key="menu.name">
  <mm-menu :title="menu.title" :subhead="menu.subhead" :items="menu.items" :target="menu.target"></mm-menu>
</v-toolbar-items>
```

Notes about this pattern:
- Every child component has same name and tag
- Best for use cases where number of child components is large or can vary

Advantages to this pattern:
- Can easily make many copies of similar components

### Mixins

Common code that multiple vue components need is defined as [mixins](https://vuejs.org/v2/guide/mixins.html).

For example, to allow multiple components to show or hide the navigation drawer, here is the drawerMixin from `mixins.js`:

```js
// Define data and methods in one place, used by multiple Vue components
var drawerMixin =
{

  data:
  function() {
    return {
      visibleDrawer: false
    };
  },

  meteor:
  {
    visibleDrawer: {
      update () {
        return Session.get('visibleDrawer');
      }
    }
  },

  methods:
  {
    toggleDrawer: function () {
      Session.set('visibleDrawer', !Session.get('visibleDrawer'));
    },
    showDrawer: function () {
      Session.set('visibleDrawer', true);
    },
    hideDrawer: function () {
      Session.set('visibleDrawer', false);
    }
  },

}
```

NOTE: While it is tempting to use that mixin to also injects the router, so every component that gets the drawerMixin can also do routing, this leads to circular imports and a P5 Bug.  See "Circular Import Dependencies" in BUGS.

### Markdown

It gets tedious to write in HTML.  So I'm using the Meteor `markdown` package, which exports `Showdown`, a JavaScript version of Markdown, so my app can parse markdown strings.

I've added a `markedMixin` which provides a `marked` method.  Pass a string with markdown text to this method and it will return raw HTML.  Use `v-html` in a Vue component to display the markdown text.  E.g.,

```html
<v-card-text v-html="marked(mdText)"></v-card-text>
```

```js
import { markedMixin } from '../../mixins.js';
import { Showdown } from 'meteor/markdown';
// markdown text for orientation
import { mdText } from './orientation.md.js';

const converter = new Showdown.converter();

var mmContentOrientation =
{
  name:
  'mm-content-orientation',

  template:
  '#mm-content-orientation-template',

  data:
  function () {
    return {
      mdText
    };
  },

  mixins:
  [
    markedMixin
  ],

};
```

I split out the markdown text into a separate file with a `.md.js` extension.  The `.js` allows this file to be imported.  You can tell Atom to syntax highlight these files as `GitHub Markdown`.

## Routing

Routing is done with [hash mode](https://router.vuejs.org/en/essentials/history-mode.html) because I can't figure out how to get `wget` to follow routes when the app is in `history mode`.


text:
# Future Updates

- [ ] Use configuration file to selectively compile CPU or GPU library.
  - [ ] Configuration file contains macros to be passed to source code.
  - [ ] A better CPU/GPU Context/Allocator design.
- [ ] Use CMake to detect GPU compute capability.
  - [ ] Ensure correct compilation.
  - [ ] Enable specific optimizations.
- [ ] Support multi-GPU computing.
  - [ ] A better GPU Context (device, stream, memory management).
  - [ ] Remove use of unified memory.
  - [ ] Use customized GPU memory allocator.
  - [ ] Depend on OpenMP to launch tasks.
  - [ ] Add alias, device transfer, assign methods to Ctxt class.
- [ ] Isolate CUDA NTT library.
- [ ] Use a fast CPU NTT library.

## API Layers
![API Layers](https://github.com/vernamlab/cuFHE/blob/master/doc/api_layers.png)

license: MIT

repository: wiedek-s/cuFHE

branch_name: refs/heads/master

extension: md

gha_license_id: MIT

license_type: permissive

repo_name: wiedek-s/cuFHE


text:
# phpci-jasmine-node-plugin
This is a plugin for [PHPCI](https://github.com/block8/phpci). It allows you
to run [jasmine-node](https://github.com/mhevery/jasmine-node) tests via PHPCI.

## Installation
*Note: This will not install `jasmine-node` for you. You will have to install that yourself.*

1. Navigate to your PHPCI path. `cd /path/to/phpci`
2. Edit the composer.json file. `nano composer.json`
3. Add `"austp\/phpci-jasmine-node-plugin": "~1.1"` in the `"require"` section.

        "require": {
            ...,
            ...,
            "austp\/phpci-jasmine-node-plugin": "~1.1"
        }
4. Download the plugin via composer. `composer update austp/phpci-jasmine-node-plugin`
5. Copy `build-plugins/jasminenode.js` to `/path/to/phpci/public/assets/js/build-plugins/jasminenode.js`

        cd /path/to/phpci/vendor/austp/phpci-jasmine-node-plugin/build-plugins
        cp jasminenode.js /path/to/phpci/public/assets/js/build-plugins/jasminenode.js

That's it as far as installation goes. Continue reading to see available options.

## Configuration
In order to configure PHPCI to run jasmine-node, you need to edit the `phpci.yml` file.
If you don't already have this file in your repository, [go ahead and add it](https://www.phptesting.org/wiki/Adding-PHPCI-Support-to-Your-Projects).
*Note: If you can't add a phpci.yml file to the repo, you can edit your project in PHPCI and configure it there.*

### Options
    executable: "/path/to/jasmine-node" | Full path to a jasmine-node executable.
    directory:  "specs/"                | The directory to run the tests on.
    log:        true                    | (optional) Log jasmine-node's output to PHPCI.

### phpci.yml
1. Navigate to your repository. `cd /path/to/repo`
2. Edit the phpci.yml file. `nano phpci.yml`
3. Add `\PHPCI_Jasmine_Node_Plugin\Jasmine_Node:` in the `"test"` section.

        test:
          ...:
            ...: ...
            ...: ...
          ...:
            ...: ...
          \PHPCI_Jasmine_Node_Plugin\Jasmine_Node:
4. Add your options under the `\PHPCI_Jasmine_Node_Plugin\Jasmine_Node:` line.

        \PHPCI_Jasmine_Node_Plugin\Jasmine_Node:
          executable: "/path/to/jasmine-node"
          directory: "specs/"
          log: true

repository: AustP/phpci-jasmine-node-plugin

repo_name: AustP/phpci-jasmine-node-plugin


text:
# trackML client for Python

*A Python library to manage your machine learning experiments with [trackML](https://github.com/sds-dubois/trackML)*

## Getting started

Be sure to have your [trackML](https://github.com/sds-dubois/trackML) server running.

Check a full working example [here](examples/simple_example.py).

In short, you can log an experiment with the following:

```
from trackml import TrackML
logger = TrackML(model_id=1)

hp = {"n_estimators": 20, "max_features": 5}
scores = {"metric1": 0.95, "metric2": 0.78}
logger.log(candidate, scores)
```

By default, this will assume your trackML server is running on `http://localhost:3000` but you can specify another port or domain when initializing the logger:
```
logger = TrackML(base_url="https://www.mydomain.com")
```

## Deferred logging

The `log` method will instantly post the experiment information. If you want to avoid potential slow downs due to the http requests, you can defer the requests to send experiments in batches (whenever the cache is full).

In that case you would call `deferred_log`:
```
# default cache size is 20
# change it at initialization: logger = TrackML(model_id=1, cache_size=50)

candidates = [...]
for candidate in candidates:
    scores = {"metric": model.eval(candidate)}
    logger.deferred_log(candidate, scores) # this will only send a request if cache is full
logger.send_cache()
```

**Important** - be sure to call `logger.send_cache()` to log pending experiments.

## Create projects and models

You can also use this client to create projects or models.

```
logger = TrackML()

project_id = logger.new_project("Awesome Project")
model_id = logger.new_model("Baseline", project_id, description="An optional description")
```

You can finally set a default model ID by calling `logger.set_model(model_id)` of specify it when calling log/deferred_log: `logger.log(candidate, scores, model_id)`.

## Ensure successful logs

By default, the client doesn't check the request was successful. To turn this on, initialize the logger as follows:
```
logger = TrackML(assert_success=True)
```

## License

[MIT License](LICENSE.md)

repository: sds-dubois/trackml-client-py

repo_name: sds-dubois/trackml-client-py


text:
USPGameDev's Programming Tutorial
=================================

This repository contains a series of lessons with which one may learn the
basics of game programming. Start from [Level 0](level_00) if you don't
have the LÖVE game framework setup yet (if you don't know what that is, then
you probably need to go there!). The real lessons start from [Level
1](level_01) onwards.

Feel free to submit any doubts as issues in this repository!

repository: uspgamedev/programming-tutorial

gha_language: Lua

repo_name: uspgamedev/programming-tutorial


text:
iq
==

This package offers a convenient way to parse and analyze I/Q files like those
produced by an [RTL-SDR][rtl-sdr-home] dongle.

See [this R vignette](doc/overview.md) for a description of some use cases.

![Example](example/example.png)

*(this is the output of [example.R](example/example.R))*

Features
========

See the embedded R help system for the full reference. Here is an overview of
the available functions:

 * Load from (`iq::FromFile`) and save to (`iq::ToFile`) plain or compressed
   binary files.

 * Cut and resample a signal (`iq::Resample`).

 * Extract ranges of complex I/Q values from the signal (`iq::SampleRange`)
   on-demand to avoid overloading the available memory.

 * Compute some common operations over complex I/Q values (`iq::Magnitude`,
   `iq::Phase`, etc.).

 * Perform power spectrum analysis (`iq::Spectrum` and `iq::Spectrogram`) of the
   signal using builtin (`iq::Rectangular`, `iq::Hamming`, etc.) or custom
   window functions.

Installation
============

Using [`devtools`][devtools]:

```R
devtools::install_github('cyrus-and/iq')
```

Motivation
==========

Although there are already a [whole][rtl-sdr-apps-1] [bunch][rtl-sdr-apps-2] of
related software, I thought, as a newbie to the SDR world, that writing this
library would be a good opportunity to both delve a bit into the unfamiliar
topic of signal analysis and to gain some expertise on the R package
development.

This is also an attempt to answer the question: *"Well, I've captured something
with [`rtl_sdr`][rtl-sdr-software], now what?"* which is probably obvious for
someone in the field but quite confusing for newcomers.

[rtl-sdr-home]: http://www.rtl-sdr.com/
[devtools]: https://github.com/hadley/devtools
[rtl-sdr-apps-1]: http://sdr.osmocom.org/trac/wiki/rtl-sdr#KnownApps
[rtl-sdr-apps-2]: http://www.rtl-sdr.com/big-list-rtl-sdr-supported-software/
[rtl-sdr-software]: http://sdr.osmocom.org/trac/wiki/rtl-sdr#rtl_sdr

repository: cyrus-and/iq

repo_name: cyrus-and/iq


text:
---
title: TeamMemberAddListingResponse
---
## ININ.PureCloudApi.Model.TeamMemberAddListingResponse

## Properties

|Name | Type | Description | Notes|
|------------ | ------------- | ------------- | -------------|
| **Entities** | [**List<UserReference>**](UserReference.html) |  | [optional] |
| **Failures** | [**List<TeamAddMemberFailure>**](TeamAddMemberFailure.html) | List of any user ids that were not added. | [optional] |
{: class="table table-striped"}

repository: MyPureCloud/platform-client-sdk-dotnet

gha_language: C#

repo_name: MyPureCloud/platform-client-sdk-dotnet


text:
Chained DropDownList Widget for Yii2
========================

Implement DropDownList chained width other DropDownList.

Installation
------------
The preferred way to install this extension is through [composer](http://getcomposer.org/download/).

Either run

```
php composer.phar require "himiklab/yii2-chained-dropdown-list-widget" "*"
```
or add

```json
"himiklab/yii2-chained-dropdown-list-widget" : "*"
```

to the require section of your application's `composer.json` file.

Usage
-----
Using as field in ActiveForm:

```php
use himiklab\chained\ChainedDropDownList;

<?= $form->field($model, 'news')->widget(
    ChainedDropDownList::className(),
    [
        'items' => [],
        'remote' => [
            'id' => 'language-drop-down',
            'url' => Url::to('newsList')
        ]
    ]
); ?>
```

Using inline:

```php
use himiklab\chained\ChainedDropDownList;

<?= ChainedDropDownList::widget([
    'items' => [],
    'remote' => [
        'id' => 'language-drop-down',
        'url' => Url::to('newsList')
    ]
]); ?>
```

repository: hsleonis/brandmakers

repo_name: hsleonis/brandmakers


text:
---
title: "documentdb"
title_tag: "azure-native.documentdb"
meta_desc: "Explore the resources and functions of the azure-native.documentdb module."
layout: api
no_edit_this_page: true
---

Explore the resources and functions of the azure-native.documentdb module.

Resources

SqlResourceSqlContainer

Package Details

Repository

Azure Native pulumi/pulumi-azure-native

License

Apache-2.0

repository: pulumi/pulumi

gha_language: Go

repo_name: pulumi/pulumi


text:
## Website Performance Optimization portfolio project

For the Udacity Front End Web Developer Nanodegree project 4, Udacity provided an online portfolio with specific bugs that needed to be optimized. In particular, the goal was to optimize the critical rendering path to make the main page render as quickly as possible when scrolling by applying the techniques picked up in the [Critical Rendering Path course](https://www.udacity.com/course/ud884).

Note: You can find a live version of this site at [http://tonirib.github.io/frontend-nanodegree-mobile-portfolio/dist/index.html](http://tonirib.github.io/frontend-nanodegree-mobile-portfolio/dist/index.html). This site uses the production code created from the Grunt tasks.

##### Dependencies

This project requires Grunt and ngrok in order to run the Gruntfile.

##### Locations

All source (dev) code is located in the src directory, while production code generated using Grunt is located in the dist directory.

##### License

All code is provided under the MIT license.

###Part 1: Optimize PageSpeed Insights score for index.html

The goal of this section was to achieve a mobile and desktop score of 90 or greater using [Google's PageSpeed Insights](https://developers.google.com/speed/pagespeed/insights/).

####The following optimizations were provided by Toni Rib:

* Created a Gruntfile.js to optimize images, minify the files, inline CSS into the HTML, and use ngrok and pagespeed to measure performance
* Changed the HTML link attribute to include a media="print" attribute for the print.css stylesheet in .html files
* Changed the call to img/profilepic.jpg to be img/build/profilepic.jpg in index.html
* Moved the Google fonts to be non-render blocking by asynchronously loading it at the bottom of the file
* Used imagemagick to resize the pizzeria.jpg image since Grunt kept having an error with this image
* Updated 'querySelectorAll' to 'getElementsByClassName' which is faster

#### Running Grunt to Produce Production Files

This section assumes the user is working on MAC OS X.

1. After cloning the project into a local respository using Git, navigate to the main project location.
2. If you are only interested in generating the production code, simply run the command 'grunt' to run all optimizations in the Gruntfile. Production code will be saved in the dist directory.
3. If you also want to check PageSpeed Insight scores using ngrok, perform the following steps:
	* Open a second tab from the Terminal and navigate to the dist directory. Run the command 'python -m SimpleHTTPServer 8080' to host the site on the local server at port 8080.
	* Go back to the first tab in the Terminal and run the 'grunt' command. The PageSpeed Insights scores will now be displayed.
4. To view the pages from the production code, navigate to the dist directory and open index.html in your browser.

###Part 2: Optimize Frames per Second in pizza.html

The goal of this section was to optimize views/pizza.html, by modifying views/js/main.js until the frames per second rate is 60 fps or higher when scrolling. In addition, the slider than changes the pizza's sizes needed to be optimized so that pizzas changed sizes in under 5ms.

####The following optimizations were provided by Toni Rib:

* In the changePizzaSizes function (line 450) I moved repeated variables outside of the for loop. In addition, I updated 'querySelectorAll' to 'getElementsByClassName' which is faster.
* In line 481, I moved the pizzaDivs variable outside of the for loop.
* In the updatePositions function (line 518) I moved 'document.body.scrollTop' outside of the for loop, calculated items.length outside of the for loop, and declared the phase variable outside of the loop as well.
* Used the screen size (line 543) to calculate the number of background pizzas to create instead of using the static # of 200, declared the elem variable outside of the for loop, and changed querySelector to getElementById which is faster.


text:
# my-notion

Made by Shay Li.

My independent implementation of my three most used page templates on Notion; like on a minimalist scale. Built to best accomodate my preferences for Notion.

# Page types

All three templates are contained within a calendar.

- Todo

Timeblocking/boxing. Uses Gridstack.  Uses a Richtext editor to allow for checkboxes in the notes. You can import events from Google calendar.

- Habits

Edit & delete habits, + switch em on upon completion. Re-order the habits too, and add new ones. A completion bar is rendered atop.

- Journal

Very simple: title & textarea.

# Data management

Uses LocalStorage. Four different "stores":
- calendar store
  - date -> what pages (todo, habit, and/or journal) exist on this date

- todo store: date ->
  - location & size of the blocks
  - checked or not checked?
  - tags, names & notes

- habits store: date ->
  - order of habits
  - switch on/off for each
  - names

 - journal store: date ->
    - title
    - entry

branch_name: refs/heads/main


text:
---
layout: post
title: "Working with Google APIs | Part 1"
description: "Exploring Google APIs using Python"
headline: "Getting started with Google APIs"
modified: 2017-03-19 10:52:08 +0530
category: [web]
tags: [google, api, web, python, youtube]
feature-img: "img/post/google-apis/google_developers_logo.gif"
author: Nikhil Kumar Singh
mathjax:
chart:
comments: true
featured: false
---

Google is more than a search engine, and we all know that!

Google provides a wide range of web products and services. And Google APIs are an important part of them!

Google provides a plethora of APIs which can be easily integrated with your web or desktop applications.

Several popular APIs provided by Google are:

- [Google YouTube API](https://developers.google.com/youtube/v3/)
- [Google Maps API](https://developers.google.com/places/)
- [Google Custom Search API](https://developers.google.com/custom-search/)
- [Gmail API](https://developers.google.com/gmail/api/)
- [Google Machine Learning APIs](https://cloud.google.com/products/machine-learning/)

...and many more!

In this tutorial series "Working with Google APIs", we are going to explore several popular APIs provided by Google using Python programming language.

This is the first part of this tutorial series. In this part we are going to learn how to:

- Create a new project on Google Cloud Platform.
- Create credentials to use Google APIs.
- Exploit YouTube Data API to extract data from YouTube.

## 1. Creating a new project

**Google API Console** lets you discover and use Google APIs.

Before you can use any Google API, you must have a **Google API Console project**. A project allows you to manage all the APIs provided by Google.

### Steps:

- Go to the [Google API Console](https://console.developers.google.com/project/_/apiui/apis/library).
- From the project drop-down, select an existing project , or create a new one by selecting **Create a new project**.

## 2. Enable API and create credentials

In order to integrate an API with your project, you need to **enable** it.

### Steps to enable API:

- Go to [Google API Console](https://console.cloud.google.com/apis) and select a project from project drop-down.
- In the sidebar under "API Manager", select "Library". Now, you can see a list of popular APIs. You can also type the name of any API in search bar too.
- Select the API you want to enable. In this article, we are going to explore **YouTube Data API**. So, in the YouTube APIs section,
  you can select the YouTube Data API.
- Click on **enable** button.

Now, in order to access enabled API by HTTP requests, you need to set up some credentials.

Google supports two mechanisms for creating credentials or unique identifiers:

- **OAuth 2.0 client IDs:** For applications that use the OAuth 2.0 protocol to call Google APIs, you can use an OAuth 2.0 client ID to generate
  an access token. The token contains a unique identifier.
- **API keys:** An API key is a unique identifier that you generate using the console. Using an API key does not require user action or consent.
  API keys do not grant access to any account information, and are not used for authorization.

If you're calling only APIs that do not require user data, such as the Google Custom Search API, Google Maps API, etc. then API keys might be simpler to use than OAuth 2.0 access tokens. However, if your application already uses an OAuth 2.0 access token, then there is no need to generate an API key as well. Google ignores passed API keys if a passed OAuth 2.0 access token is already associated with the corresponding project.

In this part, we are going to use **API keys** only for creating credentials for **YouTube Data API**.

### Steps to create an API key:

- In the sidebar under "API Manager", select **Credentials**.
- In the Credentials tab, select the **Create credentials** drop-down list, and choose **API key**.
- Currently, we will use API key to access data through python scripts, we will use an "restriction-less" key. You can impose some restrictions on your
  API-key by select the "Edit settings" option of the key.

## 3. Python scripts to interact with YouTube Data API

Once you have enabled a Google API, you can interact with it via HTTP requests.

In this part, we are going to play with [**YouTube Data API**](https://developers.google.com/youtube/v3/).

### Installations:

* Python (any version)
* Google API python client.
  You can install it using a simple pip command:
  ```
  pip install --upgrade google-api-python-client
  ```

### Example 1

In the first example, we are going to create a **youtube_search** function which will return us the data about **videos**, **channels** and **playlists** related to a search query.

Consider the code below:

```python
from apiclient.discovery import build

# arguments to be passed to build function
DEVELOPER_KEY = "Your API Key here"
YOUTUBE_API_SERVICE_NAME = "youtube"
YOUTUBE_API_VERSION = "v3"

# creating youtube resource object for interacting with API
youtube = build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION,
                    developerKey=DEVELOPER_KEY)

def youtube_search(query, max_results = 5):

    # calling the search.list method to retrieve youtube search results
    search_response = youtube.search().list(q = query,
                                            part = "id,snippet",
                                            maxResults = max_results).execute()

    # extracting the results from search response
    results = search_response.get("items", [])

    # empty list to store video, channel, playlist metadata
    videos = []
    playlists = []
    channels = []

    # extracting required info from each result object
    for result in results:
        # video result object
        if result['id']['kind'] == "youtube#video":
            video = {}
            video['id'] = result["id"]["videoId"]
            video['title'] = result['snippet']['title']
            video['descr'] = result['snippet']['description']
            video['thumbnail'] = result['snippet']['thumbnails']['default']['url']
            videos.append(video)
        # playlist result object
        elif result['id']['kind'] == "youtube#playlist":
            playlist = {}
            playlist['id'] = result['id']['playlistId']
            playlist['title'] = result['snippet']['title']
            playlist['descr'] = result['snippet']['description']
            playlist['thumbnail'] = result['snippet']['thumbnails']['default']['url']
            playlists.append(playlist)
        # channel result object
        elif result['id']['kind'] == "youtube#channel":
            channel = {}
            channel['id'] = result['id']['channelId']
            channel['title'] = result['snippet']['title']
            channel['descr'] = result['snippet']['description']
            channel['thumbnail'] = result['snippet']['thumbnails']['default']['url']
            channels.append(channel)

    return videos, playlists, channels

if __name__ == "__main__":
    result = youtube_search('Coding Blocks', max_results = 10)
    print("Videos:", result[0])
    print("Playlists:", result[1])
    print("Channels:", result[2])
```

When you run above code, you will get separate lists of videos, channels and playlist results.

A sample video element looks like this:
```
{'descr': 'Watch Arnav Gupta teaching Hacking through the Android OS Code at '
          "DroidCon 2014, India's Biggest Android Development Conference.",
 'id': 'kPwGMMVY93k',
 'thumbnail': 'https://i.ytimg.com/vi/kPwGMMVY93k/default.jpg',
 'title': 'Hacking through the Android OS code - Arnav Gupta | Coding Blocks'}
 ```
 A sample playlist element looks like this:
 ```
 {'descr': '',
 'id': 'PL8A7E8B635FF6804B',
 'thumbnail': 'https://i.ytimg.com/vi/tvC1WCdV1XU/default.jpg',
 'title': 'Buckys C++ Programming Tutorials- CodeBlocks'}
 ```
 A sample channel element looks like this:
 ```
 {'descr': 'The Coding Blocks YouTube channel is all about bringing you '
          "tutorials, tips, how to's and best practices on working your way to "
          'being the best programmer or ...',
 'id': 'UCcxbkpkf7_zhf3YceK8JMQw',
 'thumbnail': 'https://yt3.ggpht.com/-dGIgUBoa4sM/AAAAAAAAAAI/AAAAAAAAAAA/kZ1fSAxQbVA/s88-c-k-no-mo-rj-c0xffffff/photo.jpg',
 'title': 'Coding Blocks'}
 ```

The code is pretty much self-explanatory.
However, some important things to ponder upon are:

- **apiclient** is a python client to interact with the Google APIs in an easier way.
- In order to use an API, you have to build a **resource object** for that API.
  In above example, we did that using these lines of code:
  ```
  youtube = build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION,
                    developerKey=DEVELOPER_KEY)
  ```
  We passed the service name, its version and our Developer(or API) key to **build** method of **apiclient.discovery** module.
  Note that the **part** parameter specifies a comma-separated list of one or more video/playlist/channel resource properties
  that the API response will include.
- Now, we use **search.list** method of resource object to fetch search results.
  You can read more about it [here](https://developers.google.com/youtube/v3/docs/search/list).
- Once search results are available, we fetch required info from the JSON structured object.

## Example 2

In this example, we will try to extract some more content and statistical info from a video.

Consider the code below:

```python
from apiclient.discovery import build

# arguments to be passed to build function
DEVELOPER_KEY = "Your API key here"
YOUTUBE_API_SERVICE_NAME = "youtube"
YOUTUBE_API_VERSION = "v3"

# creating youtube resource object for interacting with API
youtube = build(YOUTUBE_API_SERVICE_NAME, YOUTUBE_API_VERSION,
                    developerKey=DEVELOPER_KEY)

def video_details(video_id):

    # Call the videos.list method to retrieve video info
    result = youtube.videos().list(
        id = video_id,
        part = "id,snippet,contentDetails,statistics",
    ).execute()

    # Extracting required info about video
    video = {}
    video['title'] = result['items'][0]['snippet']['title']
    video['tags'] = result['items'][0]['snippet']['tags']
    video['descr'] = result['items'][0]['snippet']['description']
    video['content'] = result['items'][0]['contentDetails']
    video['stats'] = result['items'][0]['statistics']

    return video

def video_comments(video_id, max_results = 10):

    # Call the comments.list method to retrieve video comments
    results = youtube.commentThreads().list(
        videoId = video_id,
        part = "id,snippet",
        order = "relevance",
        textFormat = "plainText",
        maxResults = max_results%101
    ).execute()

    comments = []

    # Extracting required info from each result
    for result in results['items']:
        comment = {}
        comment['id'] = result['id']
        comment['text'] = result['snippet']['topLevelComment']['snippet']['textOriginal']
        comment['likes'] = result['snippet']['topLevelComment']['snippet']['likeCount']
        comments.append(comment)

    return comments

if __name__ == "__main__":
    video_id = "vTaxdJ6VYWE"

    details = video_details(video_id)
    comments = video_comments(video_id)

    pprint(details)
    pprint(comments)
```

The details of the video fetched using above script looks like this:
```
{'content': {'caption': 'false',
             'definition': 'hd',
             'dimension': '2d',
             'duration': 'PT1H26M22S',
             'licensedContent': True,
             'projection': 'rectangular'},
 'descr': 'Although numeric data is easy to work with in Python, most '
          'knowledge created by humans is actually raw, unstructured text. By '
          'learning how to transform text into data that is usable by machine '
          'learning models, you drastically increase the amount of data that '
          "your models can learn from. In this tutorial, we'll build and "
          'evaluate predictive models from real-world text using scikit-learn. '
          '(Presented at PyData DC on October 7, 2016.)\n'
          '\n'
          'GitHub repository: '
          'https://github.com/justmarkham/pydata-dc-2016-tutorial\n'
          'Enroll in my online course: http://www.dataschool.io/learn/\n'
          'Subscribe to the Data School newsletter: '
          'http://www.dataschool.io/subscribe/\n'
          '\n'
          '== OTHER RESOURCES ==\n'
          'My scikit-learn video series: '
          'https://www.youtube.com/playlist?list=PL5-da3qGB5ICeMbQuqbbCOQWcS6OYBr5A\n'
          'My pandas video series: '
          'https://www.youtube.com/playlist?list=PL5-da3qGB5ICCsgW1MxlZ0Hq8LL5U3u9y\n'
          '\n'
          '== JOIN THE DATA SCHOOL COMMUNITY ==\n'
          'Blog: http://www.dataschool.io\n'
          'Newsletter: http://www.dataschool.io/subscribe/\n'
          'Twitter: https://twitter.com/justmarkham\n'
          'YouTube: https://www.youtube.com/user/dataschool?sub_confirmation=1',
 'stats': {'commentCount': '32',
           'dislikeCount': '0',
           'favoriteCount': '0',
           'likeCount': '62',
           'viewCount': '2828'},
 'tags': ['python',
          'data science',
          'machine learning',
          'natural language processing',
          'text analysis',
          'scikit-learn'],
 'title': 'Machine Learning with Text in scikit-learn (PyData DC 2016)'}
```

Also, one of the comment elements looks like this:
```
{'id': 'z135ix34vmvcwtwug22iidozxmzexdei304',
  'likes': 0,
  'text': 'Thank you Kevin! Such informed tutorial with great details but not '
          'redundant!'}
```

In above code,

- we used **videos.list** method to retrieve all metadata about the video by simply passing its *id* to the **video_details** function.
- Similarly, we used **commentThreads.list** method to retrieve all metadata about comments under a video by simply passing
  video id to the **video_comments** function.

**Note:** The above two examples are intended to get you comfortable with the google-api-python-client and YouTube Data API. You can refer to [YouTube Data API docs](https://developers.google.com/youtube/v3/docs/) to implement more methods which involve fetching data from YouTube.

So far, we have just seen how to **fetch** various types of data from YouTube Data API.
In next parts of this tutorial series, we will see how to manipulate the YouTube user data on YouTube using this API.

branch_name: refs/heads/gh-pages

gha_language: JavaScript


text:
Subsample peat (stored at +4ºC until all subsampled)
==============

+  **Ingrowth Peat**
    1. One subsample for determining gravimetric soil moisture
        1. \>15 g/sample or however much can be packed into the pre-weighted aluminum trays
            1. the more sample the better
            2. peat (especially fresh peat) contains ~90% of water
        2. Dried peat can be stored in coin bags
        3. Part of the dried peats can be used to determine soil pH (per location, per geography)
    2. One subsample for microbial biomass analysis
        1. See sequential extraction protocol
        1. Directly subsample into 50ml conical tubes, record the exact weight!
        2. 8.1 ± 0.1 g
    3.  In Whirl Pack
        2. 20-30 g/sample
        3. Store at -80ºC
    4. One subsample for Ergosterol analysis
        1. In Whirl Pack
        2. 15-20 g/sample
        3. Store at -20ºC
    5. One subsample for soil enzyme analysis
        1. In Whirl Pack
        2. 10-15 g/sample
        3. Store at -20ºC
    6. Archive samples
        1. In Whirl Pack
        2. Should have >10g left
        3. Store at -80ºC

repository: chnops/Protocols

repo_name: chnops/Protocols


text:
# Changelog

## [6.0.1] - 2022-10-05

### Fixes
- Updated third party packages to mitigate potential security vulnerabilities.

## [6.0.0] - 2022-09-30

### Breaking changes
- The issuance event entries returned by the *retrieveAssetIssuanceHistory* method for non-fungible assets are different
  from the ones returned for regular (fungible) assets as per the new behavior of version 0.12 of the Catenis API. The
  observed differences are: the `amount` key is replaced by a new `nfTokenIds` key, which lists the IDs of the
  non-fungible tokens that have been issued; and the `holdingDevice` key is replaced by a new `holdingDevices`
  key, which lists the Catenis virtual devices to which the issued non-fungible tokens have been assigned.

### New features
- Added support for changes introduced by version 0.12 of the Catenis API: new non-fungible assets feature, including
  the new API methods Issue Non-Fungible Asset, Reissue Non-Fungible Asset, Retrieve Non-Fungible Asset Issuance
  Progress, Retrieve Non-Fungible Token, Retrieve Non-Fungible Token Retrieval Progress, Transfer Non-Fungible Token,
  and Retrieve Non-Fungible Token Transfer Progress.

## [5.0.0] - 2021-09-02

### Breaking changes
- The list of current asset holders returned by the *listAssetHolders* method may now include an entry that reports the
 total asset amount that is currently migrated to foreign blockchains as per the new behavior of version 0.11 of the
 Catenis API. That entry differs from the regular ones in that the `holder` key is missing and a new boolean type key
 named `migrated`, the value of which is always `true`, is present.

### New features
- Added support for changes introduced by version 0.11 of the Catenis API: new asset export feature, including the new
 API methods Export Asset, Migrate Asset, Asset Export Outcome, Asset Migration Outcome, List Exported Assets, and
 List Asset Migrations.

## [4.1.0] - 2020-07-02

### New features
- Added support for changes introduced by version 0.10 of the Catenis API: new public API method Retrieve
 Message Origin.

## [4.0.1] - 2020-01-23

### Changes
- Add missing information to header comment of logMessage() and readMessage() methods and their asynchronous counterpart.
- Update README file to fix sample code for retrieving information about a message's container.

## [4.0.0] - 2020-01-21

### Breaking changes
- When calling the *LogMessage* and *SendMessage* methods — and their asynchronous counterpart — without specifying a
 value for the new `off-chain` key of the *options* parameter, off-chain messages are used. Thus any existing code that
 uses those methods, when changed to use this new version of the Catenis API client — provided that the client is
 instantiated with its default API version (0.9) —, will produce a different result. To get the same behavior as before,
 the `off-chain` key of the *options* parameter needs to be set to ***false***.

### Changes
- The default version of the Catenis API (when instantiating the API client) is now set to 0.9.

### New features
- As a consequence for targeting version 0.9 of the Catenis API, the new features introduced by that version
 are supported: log, send, read and retrieve container info of Catenis off-chain messages.

## [3.0.1] - 2019-08-24

### Fixes
- Query string parameters of type boolean with a false value is correctly formatted.

## [3.0.0] - 2019-08-20

### Breaking changes
- The `countExceeded` key of the associative array returned from a successful call to the *listMessages* method has been
 replaced with the new `hasMore` key.
- The `countExceeded` key of the associative array returned from a successful call to the *retrieveAssetIssuanceHistory*
 method has been replaced with the new `hasMore` key.

### Changes
- Changed interface of *listMessages* method: first parameter renamed to `selector`; new parameters `limit` and `skip` added.
- Changed interface of *retrieveAssetIssuanceHistory* method: new parameters `limit` and `skip` added.

### New features
- Added options (when instantiating API client) to send/receive compressed data, which is on by default.
- Added support for changes introduced by version 0.8 of the Catenis API: "pagination" (limit/skip) for API
 methods List Messages and Retrieve Asset Issuance History; new URI format for notification endpoints.

## [2.1.3] - 2019-06-22

### Fixes
- Avoid that CPU be over allocated (CPU time ~ 100%) when automatically running the promise task queue,
 which is the default.

### Changes
- New `pumpInterval` option used to set the interval for periodically running the promise task queue
 when instantiating the Catenis API PHP client.

## [2.1.2] - 2019-06-18

### Fixes
- Avoid that JSON payload of API method calls include escaped characters.

## [2.1.1] - 2019-06-10

### Changes
- Reference updated version of dependency package ratchet/pawl, which includes a fix to correctly use HTTPS scheme for secure connections.

## [2.1.0] - 2019-05-31

### New features
- WebSocket notification channel object emits new `open` event.

## [2.0.0] - 2019-05-02

### Breaking changes
- Changed interface of method *sendMessage*: parameters `message` and `targetDevice` have swapped positions.
- The associative array returned from a successful call to the *readMessage* method has a different structure.

### New features
- Added support for version 0.7 of the Catenis API: log, send and read message in chunks.

## [1.0.3] - 2019-01-02

### Changes
- Changed the wording of the library title.
- Made adjustments and corrections to the sample code shown in the README file.

## [1.0.2] - 2018-12-31

### Fixes
- Update dependency package ratchet/pawl to fix issue with authenticating Catenis (WebSocket) notification connections
 on the sandbox environment.

## [1.0.1] - 2018-12-29

### Changes
- Added missing LICENSE file.

## [1.0.0] - 2018-12-07

### New features
- Initial version of the library.

repository: blockchainofthings/CatenisAPIClientPHP

repo_name: blockchainofthings/CatenisAPIClientPHP


text:
---
date: 2020-12-18
layout: rafaga
rafagas:
- desc: Amazon Location Service wants to make it easier and more cost-effective to
    add maps, location knowledge, and other location-based features to all kinds of
    web and mobile apps
  keyw: amazon
  link: https://aws.amazon.com/blogs/aws/amazon-location-add-maps-and-location-awareness-to-your-applications/
  microlink:
    desc: We want to make it easier and more cost-effective for you to add maps, location
      awareness, and other location-based features to your web and mobile applications.
      Until now, doing this has been somewhat complex and expensive, and also tied
      you to the business and programming models of a single provid…
    image: https://d2908q01vomqb2.cloudfront.net/da4b9237bacccdf19c0760cab7aec4a8359010b0/2020/12/16/Amazon-Location-Services-1.jpg
    logo: https://logo.clearbit.com/amazon.com
    title: Amazon Location – Add Maps and Location Awareness to Your Applications
      | Amazon Web Services
- desc: The Humanitarian Topographic Atlas is the set of detailed, up-to-date, high-quality
    topographic maps created to support the field operations of the UN World Food
    Program (WFP)
  keyw: Spain
  link: https://hta.gis.wfp.org/
  microlink:
    title: HTA - Humanitarian Topographic Atlas
- desc: Naismith International Park is a topographic map illustration created by Kirk
    Goldsberry that features statistical information, decades of basketball hoop history,
    and legends for lovers of the sport.
  keyw: basketball
  link: https://www.thegoldenhexagon.com/products/naismith-international-park-map?variant=37317523112086
  microlink:
    desc: 'Welcome to Naismith International Park. Created by Kirk Goldsberry this
      topographic map features statistical insight, basketball legends, and decades
      of hoops history. Sized 18″ x 24″, Giclée printing quality on 70lb. matte paper.
      Frame not included. From Kirk: “This map blends two of my passions: c…'
    image: https://cdn.shopify.com/s/files/1/0489/2514/7286/products/NaismithInternationalPark1_1200x1200.png?v=1611631061
    logo: https://cdn.shopify.com/s/files/1/0489/2514/7286/files/Artboard_1_2x_8d9bcde3-fcb2-417d-a8e9-73ce937658d4_150x150.png?v=1600804162
    title: Naismith International Park Map 18 x 24″ Print
rid: 1473
---

repository: geoinquiets/rafagas

gha_language: SCSS

gha_license_id: NOASSERTION

repo_name: geoinquiets/rafagas


text:
# Contao CORS

This Contao 4.x bundle was developed to extend the CMS by supporting control of CORS headers on frontend.

## Limit Access

By default this plugin is accepting requests on behalf of any domain. However, this is significantly weaking security of your website and thus you should explicitly lists all domains that might access your website in `app/config/parameters.yml` by adding this parameter:

```yaml
parameters:
    ...
    cors.domains:
        - http://example.com
        - http://www.example.com
        - https://secure.example.com
```

repository: cepharum/contao-cors

repo_name: cepharum/contao-cors


text:
# Tuturial

`hsr` is a code-generator. It takes an OpenAPIv3 spec as an input and generates Rust
as it's output. It can massively reduce the boilerplate and general annoyance of writing
an HTTP API, either for an internet-facing web service or an internal micro (or macro!) service.
And becuase it is just a thin layer on top of `actix-web`, performance is excellent.

OpenAPIv3, aka swagger, is a popular format for specifying an HTTP API.
If you aren't familiar with OpenAPI, I recommend having at least a
[quick skim of the the docs](https://swagger.io/docs/specification/about/) before proceeding.

The generated Rust code presents an interface (i.e. a trait) which the user should implement.
Once that trait is implemented, the server is ready to go. `hsr` takes care of
bootstrapping the server, url routing, serializing the inputs and outputs and other
boilerplate.

Rust's powerful type system makes this a particularly nice workflow because 'if it compiles,
it works'.

Right, enough talk, lets get started. Make a new project.

``` sh
cargo new tutorial
cd tutorial
```
We'll use the handy [`cargo-edit`](https://crates.io/crates/cargo-edit) to add our
dependencies.

``` sh
cargo add -B hsr-codegen        # build dependency
cargo add hsr actix-rt serde    # runtime dependencies
```

## Hello HSR!

First, we'll define an api. Create a `spec.yaml` file containing the following:
``` yaml
# spec.yaml
openapi: "3.0.0"
info:
  version: 0.0.1
  title: hsr-tutorial
servers:
  - url: http://localhost:8000

paths:
  /hello:
    get:
      operationId: hello
      responses:
        '200':
          description: Yes, we get it, hello
```

This is just about the simplest possible API. It exposes a single route, `GET /hello`,
to which it responds with a `200 OK`. That's it. Yes, I know it's boring, we'll make it
WACKY later - for now we're just going to build it.

Create a `build.rs` file in your project root:

```rust
// build.rs

use hsr_codegen;
use std::io::Write;

fn main() {
    let code = hsr_codegen::generate_from_yaml_file("spec.yaml").expect("Generation failure");

    let out_dir = std::env::var("OUT_DIR").unwrap();
    let dest_path = std::path::Path::new(&out_dir).join("api.rs");
    let mut f = std::fs::File::create(&dest_path).unwrap();

    write!(f, "{}", code).unwrap();
    // If we alter the spec.yaml, we should rebuild the api
    println!("cargo:rerun-if-changed=spec.yaml");
}
```
Now if we run `cargo build`, it does... something. Specifically, we just told Rust
that at build-time it should:
* Open the spec file
* Generate our interface code from the spec
* Find the magic OUT_DIR and write the code to `$OUT_DIR/api.rs`

Nice! But not very useful as-is. To actually use this code, we need to get it into our
project source.

Create a file `src/lib.rs` containing the following:

```rust
pub mod api {
    include!(concat!(env!("OUT_DIR"), "/api.rs"));
}
```
Now we can compile! Go! Or, actually, wait a sec. We are going to codegen an interface.
Really, we want to be able to view our API. But viewing the raw code isn't very
enlightening (and Rust doesn't make it easy), instead we view it in `rustdoc`.
``` rust
$ cargo doc --open
```
Ok, this time it did something useful. Inside the `api` module we can see a promising-sounding
things like `client` and `server` modules and an `HsrTutorialApi` trait.

The `HsrTutorialApi` trait has a rather intimidating definition, something like:

``` rust
trait HsrTutorialApi {
    fn hello<'life0, 'async_trait>(&'life0 self) -> Pin<Box<dyn Future<Output = Hello> + 'async_trait>>
    where
      'life0: 'async_trait,
      Self: 'async_trait;
}
```
This is not as complicated as it looks. Basically this trait should be read as:

```rust
trait HsrTutorialapi {
    async fn hello(&self) -> Hello;
}
```
where `Hello` is defined elsewhere. Which we can see closely matches the definition in `spec.yaml`.

Why does the definition... not look like that? Well, unfortunately "async-in-traits" is not yet
supported [(issue)](https://github.com/rust-lang/rfcs/issues/2739) so for now we work around it
with the amazing [`async-trait`](https://github.com/dtolnay/async-trait),
which however gives us these slightly inscrutable api definitions.

Lets gloss over this for now and implement the trait. Continuing in `src/lib.rs`:

```rust
// src/lib.rs

/* .. previous code .. */

struct Api;

#[hsr::async_trait::async_trait(?Send)]
impl api::HsrTutorialApi for Api {
    async fn hello(&self) -> api::Hello {
        api::Hello::Ok
    }
}
```
Notice that we've used the `async_trait` macro (conveniently re-exported from hsr)
to allow us to implement the trait as we would 'like' it to be written, rather than as it is defined
according to the docs.

The last step is to serve our api. We can see from the api docs that there is a function
in `tutorial::api::server` with the signature

``` rust
pub async fn serve<A: HsrTutorialApi>(api: A, cfg: Config) -> std::io::Result<()>
```
so let's use that.

In `src/main.rs`:

``` rust
use tutorial::{api, Api};

#[actix_rt::main]
async fn main() -> std::io::Result<()> {
    let config = hsr::Config::with_host("http://localhost:8000".parse().unwrap());
    api::server::serve(Api, config).await
}
```

That's it, the webserver is ready. We're going to test it with [`httpie`](https://httpie.org/), which
can be installed with `pip3 install httpie --user`.

``` sh
// terminal 1
cargo run

// terminal 2
➜  ~ http --print hH :8000/hello
GET /hello HTTP/1.1
# ...

HTTP/1.1 200 OK
```
It lives!

## That's not fun, make it fun

Fine, very nice. What else can this thing do? Let's flex our muscles.

Add the following to you `spec.yaml`:

```yaml
# spec.yaml

  # ... previous code ...

  /greet/{name}:
    get:
      operationId: greet
      parameters:
        - name: name
          in: path
          required: true
          schema:
            type: string
        - name: obsequiousness
          in: query
          required: false
          schema:
            type: integer
      responses:
        '200':
          description: If you can't say something nice...
          content:
            application/json:
              schema:
                type: object
                required:
                  - greeting
                properties:
                  greeting:
                    type: string
                  lay_it_on_thick:
                    $ref: '#/components/schemas/LayItOnThick'

components:
  schemas:
    LayItOnThick:
      type: object
      required:
        - is_wonderful_person
        - is_kind_to_animals
        - would_take_to_meet_family
      properties:
        is_wonderful_person:
          type: boolean
        is_kind_to_animals:
          type: boolean
        would_take_to_meet_family:
          type: boolean
```

Now if we re-run `cargo doc` and refresh our browser, we have some new goodies. In the trait definition:

``` rust
trait HsrTutorialApi {
    // .. previous definition

    fn greet<'life0, 'async_trait>(&'life0 self, name: String, obsequiousness_level: Option<i64>)
        -> Pin<Box<dyn Future<Output = Greet> + 'async_trait>>
    where
        'life0: 'async_trait,
        Self: 'async_trait;
}
```
... which we have learned should be read as

``` rust
trait HsrTutorialapi {
    // ...

    async fn greet(&self, name: String, obsequiosness_level: Option<i64>) -> Greet;
}
```

We implement it like so:

``` rust
#[hsr::async_trait::async_trait(?Send)]
impl api::HsrTutorialApi for Api {
    // ... previous

    async fn greet(&self, name: String, obsequiousness_level: Option<i64>) -> api::Greet {
        let obs_lvl = obsequiousness_level.unwrap_or(0);
        let lay_it_on_thick = if obs_lvl <= 0 {
            None
        } else {
            Some(api::LayItOnThick {
                is_wonderful_person: obs_lvl >= 1,
                is_kind_to_animals: obs_lvl >= 2,
                would_take_to_meet_family: obs_lvl >= 3,
            })
        };
        api::Greet::Ok(api::Greet200 {
            greeting: format!("Greetings {}, pleased to meet you", name),
            lay_it_on_thick,
        })
    }
}
```

That's our new endpoint implemented. Let's try it out:

``` sh
➜  ~ http ":8000/greet/Alex"
HTTP/1.1 200 OK

{
    "greeting": "Greetings Alex, pleased to meet you",
    "lay_it_on_thick": null
}

➜  ~ http ":8000/greet/Alex?obsequiousness=1"
HTTP/1.1 200 OK

{
    "greeting": "Greetings Alex, pleased to meet you",
    "lay_it_on_thick": {
        "is_kind_to_animals": false,
        "is_wonderful_person": true,
        "would_take_to_meet_family": false
    }
}

➜  ~ http ":8000/greet/Alex?obsequiousness=50"
HTTP/1.1 200 OK

{
    "greeting": "Greetings Alex, pleased to meet you",
    "lay_it_on_thick": {
        "is_kind_to_animals": true,
        "is_wonderful_person": true,
        "would_take_to_meet_family": true
    }
}
```

Beautiful! This API really knows how make you feel good about yourself.

That's it for now. Take a look at the `petstore` example for a more complex spec
that implements a somewhat-realistic looking API.

repository: adwhit/hsr

gha_language: Rust

repo_name: adwhit/hsr


text:
# externalsort
external sorting for csv file with customized comparator and support to sort with encrypted file

## Learning purpose
here is a project for you to learn how to do external sorting. the knowledge of it u can view here. https://15445.courses.cs.cmu.edu/fall2019/slides/10-sorting.pdf

You can clone this project, and read the code architecture.
The Entrance class is `ExternalSort.java`; the core method is `sortCsv(...)`;

To achieve this algorithm, there are two step.

* first, you need split one large file to a lot of sorted small file which used this `BatchSortedFileProducer.java`

* second, merge them with a lot of steps which used this `SortedFilesMerger.java`

Your task is to implement 3 methods in these two files. (search **'TODO'** to easily find them)

After finished implementation, you can run the `ExternalSortTest.java` test cases to verify your program have bug or not.

**There are a lot of paramter passed in the method you implement, read the comments and be careful with them.**

## Using purpose
If you want to find a library help do external sorting.

You could search `'ans.txt'` in the project and **use the code to fulfill TODO methods.**

repository: yixuaz/externalsort

gha_language: Java

repo_name: yixuaz/externalsort


text:
# Finite State Machine

## Subscribes to:
* odometry/filtered
* object_positions_out

## Action servers
* guidance/move

## Package Description

The finite state machine determines the execution of the AUV's mission. The AUV's mission behaviour is divided into different states, each with one or more tasks to complete, depending on the mission specifics. The state machine is implemented with the python library SMACH. The state machine script which is under development is scripts/simulator_state_machine.py. Its inputs are the object positions published by the landmarks node as well as the odometry data being published on the odometry/filtered. The state machine controls the movement of the AUV by sending goals containing the target position to the guidance/move-action server located in the guidance interface.

## Scripts
 - **simulator_state_machine.py:** The main state machine script which is under development.
 - **four_corner_mission.py:** State machine script intended for testing/data collection.
 - **fsm_helper.py:** Contains functions used by the state machine scripts, mainly los_move() and dp_move()
 - **goal_pose_helper.py:** ROS-Node which publishes a hard coded position message (used for state machine testing).

## src/sm_classes
Contains classes which will be the code running in some of the states.

## tests
Unit test scripts for state machine development (work in progress)

## Overview of Robosub 2021 state machine
todo

## Helper code

In addition to the state machines, this package contains a helper script, 'fsm_helper'. This makes the communication with the guidance interface
easier and the state-machine code simpler. It takes care of the action server/client and supplies *guidancemode*_move() functions for use in the state machine code. It (currently) also implements any other specific logic required to execute a task.

## How to run a mission

### in simulator

1. Open a window and start gazebo:
	```bash
	$ roslaunch simulator_launch <world_of_choice>.launch
	```

2. Open another window and lauch nodes neccessary for operating auv:
	```bash
	$ roslaunch auv_setup auv.launch type:=simulator
	```

3. Open a third window and lauch the desired state machine script:
	```bash
	$ roslaunch finite_state_machine <state_machine_of_choice>.launch
	```

### on AUV

1. Lauch nodes neccessary for operating auv:
	```bash
	$ roslaunch auv_setup auv.launch type:=real
	```

1. Lauch the desired state machine (eg. pooltest):
	```bash
	$ roslaunch finite_state_machine <state_machine_of_choice>.launch
	```

repository: oysand/Vortex-AUV

branch_name: refs/heads/development

repo_name: oysand/Vortex-AUV


text:
QuickVtk
===
##### Build Instructions
macOS
----

### 1. Download and install [CMake](https://cmake.org)

### 2. Download and install [Qt](https://www.qt.io/download/)

### 3. Build VTK

- Launch [**CMake**](https://cmake.org) and set the paths to build [**VTK**](http://www.vtk.org) from the `libs` folder:

	- **src**: `QuickVtk/libs/src`
	- **bin**: `QuickVtk/libs/bin`

- Press **Configure** and specify a project generator. It is recommended to use Unix Makefiles for faster builds

- Use the **VTK\_GIT\_TAG** attribute to specify a commit hash which will be used to download and build a specific [**VTK**](http://www.vtk.org)-version from the remote repository

- Press **Configure** and then **Generate**

- Open the terminal and navigate to `/libs/bin` in the project directory. From there, use the **make** command to invoke the build process. [**VTK**](http://www.vtk.org) will first be cloned so make sure you are connected to the internet

### 4. Build QuickVtk

- Launch [**CMake**](https://cmake.org) and set the paths accordingly:

	- **src**: `QuickVtk`
	- **bin**: `QuickVtk/bin`

- Press **Configure** and select a project generator

- In most cases, [**CMake**](https://cmake.org) will fail to find [**Qt**](https://www.qt.io/). Confirm the error dialog and enter `Qt` in the search field. Set the path to `Qt5Config.cmake` which might vary depending on your [**Qt**](https://www.qt.io/)-installation.

- Press **Configure** again

- Another error will probably pop up. This time [**VTK**](http://www.vtk.org) was not found. Type `VTK` in the search field and set the path to `libs/bin/VTK/bin` from the project root directory

- Press **Configure** and then **Generate**

### 4.1 Building via Xcode

- Open the generated `.xcodeproj` file from the `bin` folder

- Change the build target from `ALL_BUILD` to `QuickVtk`

- Hit ⌘ Command + `R` to build and run QuickVtk

repository: jayavardhanravi/QuickVtk

repo_name: jayavardhanravi/QuickVtk


text:
# ai4eu-hexlite-bundle

AI4EU Experiments Component containing Hexlite and several plugins:

* Stringplugin
* Testplugin
* OWLAPI Plugin

A gRPC service is implemented that permits the usage of Hexlite via a gRPC/Protobuf interface. The interface is the generic Answer Set Solver interface.

# Contents

* `grpcservice/` contains the gRPC service.
* `tests/` contains testing scripts.
* `scripts/` contains helpful scripts for testing/building/running.
* `hexlite/` contains a git submodule with the Hexlite git repo.
* `hexlite-owlapi-plugin/` contains a git submodule with the Hexlite OWLAPI plugin git repo.

# How to build this repository

* clone all submodules

    `git submodule init`
    `git submodule update`


text:
## Getting Started
### Set up a Virtual Environment

#### Database - Docker (Optional)

Write database password in .env:

    POSTGRES_PASSWORD=somepassword

Define .env location in docker-compose-db.yml under the corresponding database service:

    services:
      db:
        image: postgres:11-alpine
        env_file:
          - .env

Create and start the database for development:

    docker-compose -f docker-compose-db.yml up

#### Python - Built-in `venv`

Create your virtual environment:

    python3 -m venv venv

And enable it:

    . venv/bin/activate

#### Python - [virtualenvwrapper](https://virtualenvwrapper.readthedocs.org)

You need to specify your python path when creating the virtual environment:

    mkvirtualenv --python=$(which python3) pycontw2016

#### Node.js - [nvm](https://github.com/creationix/nvm)

Switch to version specified in `.nvmrc`:

    nvm use

### Install Dependencies

Use pip to install Python depedencies:

    pip install -r requirements.txt

Use Yarn to install Node dependencies:

    yarn install --dev

### Set up Local Environment Variables for Database

Settings are stored in environment variables via [django-environ](http://django-environ.readthedocs.org/en/latest/). The quickest way to start is to copy `local.sample.env` into `local.env`:

    cp src/pycontw2016/settings/local.sample.env src/pycontw2016/settings/local.env

Default is sqlite3, you can change to connect `postgres`. Copy `local.sample.env` and change its parameters to your personal setting.
Then edit the `SECRET_KEY` line in `local.env`, replacing `{{ secret_key }}` into any [Django Secret Key](http://www.miniwebtool.com/django-secret-key-generator/) value. An example:

    SECRET_KEY=twvg)o_=u&@6^*cbi9nfswwh=(&hd$bhxh9iq&h-kn-pff0&&3

If you’re using a database for the first time, create a database named `pycontw2016` owned by the database user specified in the env file:

> Enter pycontw_db_1 container
```cmd
docker exec -it pycontw_db_1 psql -U postgres
```

```sql
# Replace "postgres" with your specified role.
CREATE DATABASE pycontw2016 with owner = postgres;
```

After that, just run the migration.

### Get Ready for Development

`cd` into the `src` directory:

    cd src

#### Migrate the database:

    python manage.py migrate

#### Create Super User

    python manage.py createsuperuser

#### Compile localized translation

    python manage.py compilemessages

Now you’re all set!

## Run the Development Server

    python manage.py runserver

gha_language: HTML


text:
---
title: "View Results on Sysdig Secure Dashboard"
chapter: false
weight: 44
---

The beauty of the Amazon ECS Fargate with Sysdig is that you have a centralised location to report on your scanning results.

1. Log into Sysdig Secure, and Browse to 'Image Scanning > Scan Results'.

    ![Sysdig Secure](/images/40_module_2/SysdigSecure02.png)

2. You can drill into `amazon/amazon-ecs-sample` to see details results of the scan

    ![Sysdig Secure](/images/40_module_2/SysdigSecure03.png "image_tooltip")


text:
<img src="resource/seanim_dark.png" alt="SEAnim" style="width: 480px;"/>

# Open-Source Binary Animation Format

## [Specification](spec.md)
SEAnim file format specification for version 1.0.2.

## Plugins
SEAnim plugins for various 3D software suites.
+ [io_anim_seanim](https://github.com/SE2Dev/io_anim_seanim) (Blender)
+ [SETools](https://github.com/dtzxporter/SETools) (Maya)

## Libraries
Libraries that handle reading / writing SEAnim files.
+ [seanim.py](https://github.com/SE2Dev/io_anim_seanim/blob/master/seanim.py) (Python) - Part of the *io_anim_seanim* plugin above
+ [SELibDotNet](https://github.com/dtzxporter/SELibDotNet) (.NET)

## Changes
| Version | Commit | Remarks |
|:--------|:-------|:--------|
| v1.0.0 | b8f36bb7d9ab450884f640d25cef1f77253ccffc | Initial Release |
| v1.0.1 | 3c93edaabc6a34f59e4dbb92a493ddd2265a9668 | Revision 1 - Corrects various spec issues with frame_t and bone_t; Clarifies ambiguous definitions |
| v1.0.2 | 5dd1efb9342ceab90c77dbd689852608a17ccc74 | Revision 2 - Corrects an issue where the incorrect type could be chosen for frame_t |


text:
mattamp
=======

# Description

Enables big emoji for Mattermost like [slamp](https://github.com/16g/slamp).

# Prerequisite

* Python3
* reqeusts
* Enabled the following settings in Mattermost
  - Custom Emoji
  - Custom Slash Commands
  - Personal Access Tokens
* An admin's personal access token

# Getting started

1. Create `.env` file from `.env.template`
2. Run server
   ```
   $ source .env
   $ python3 app.py
   ```
3. Add custom emojis to Mattermost
4. Add a custom slash command
5. Type slash command on Mattermost like this
   ```
   /stamp :custom_emoji:
   ```

# Notes

* First time only, emoji is displayed as an attached file and the posting user becomes admin user.
  - After the second time, emoji is displayed as an image link and the posting user name is impersonated.
  - If you delete the first time post, the image link will be unavailable after Mattermost clean up process.
    - So, you should not delete the first time post.

* If `IMPERSONATE` option is true, emoji message is posted as user post completly.
* If `IMPERSONATE` option is false, emoji message is displayed as a return of slash command (added `BOT`).

* If `IMPERSONATE` option is true, this server will automatically create User Access Token and store it as a local file.
  - Use the option internally.


text:
# ports

##Usage:
To get the next available host ports on localhost docker.

Often docker compose files will be broken down into multiple files for different services.
When developing a new service I had to go through multiple files and look for the next available port to use.
This CLI application will receive a path and find all docker compose files in that path. It will find all the available ports and print them to stdout.

It can also filter ports based on `--port` flag. for example:

if you are cloning this repo:

`go run main.go grab --directory ${your_directory} --port=8xxx`

if you are using the binary:

`./ports grab --directory ${your_directory} --port 80xx`

above command will return the next set of available ports matching 8xxx pattern ( e.g. 8901)

`--port` is optional and `--directory` will default to `"."`

repository: ninaRali/ports

repo_name: ninaRali/ports


text:
---
layout: page
title: "Help spread the word about WeekPlan"
date: 2013-11-02 10:52
author: aymeric
wordpress_id: 815
navigation: True
permalink: /help-spread-word-weekplan/
class: post-template
comments: true
categories: []
tags: []
---

If you love using Week Plan, chance is that other people do as well.

We are still a small team and the marketing budget is still tight. Would you like to help us out?

As you know, a user's recommendation is always more convincing that the creator's pitch so I would appreciate if you'd accept checking out the following links and giving your honest opinion about Week Plan.

## Facebook

If you haven't done it yet, please mention Week Plan to your friends. [Here is a link to make it easy for you](http://www.facebook.com/sharer/sharer.php?u=http://weekplan.net).

## Twitter

Lots of people discover Week Plan via twitter. [Tell people what is special about Week Plan](http://clicktotweet.com/7_89a).

## Your blog

If you have got your own blog, how about showing people how you use Week Plan yourself?
Writing a blog post and including a link back to Week Plan would be very useful because Week Plan would start to rank higher in Google.

If you do write a blog post, let us know and we will help promote it!

## Quora

Quora is a Questions & Answers website where people often ask what task management tool people recommend.

I have listed here some of these questions. Feel free to post your own answer or upvote another Week Plan user's.

*   [What is your favorite productivity app?](http://www.quora.com/Productivity/What-is-your-favorite-productivity-app) ([my answer](http://qr.ae/NQPUL))
*   [What is the best todo manager?](http://www.quora.com/What-is-the-best-to-do-manager) ([my answer](http://qr.ae/NWj1m) can we get it to 10 upvotes?)
*   [What is the best method for keeping a todo list?](http://www.quora.com/What-is-the-best-method-for-keeping-a-to-do-list) ([my answer](http://qr.ae/NQPEU))
*   [Which is the most popular webapp for goal management?](http://www.quora.com/Which-is-the-most-popular-webapp-for-goal-management-(not-tasks-rather-management-of-life-goals)) ([my answer](http://qr.ae/NQP0Z))
*   [Which is the best simple task management tool for individuals](http://www.quora.com/Which-is-the-best-simple-task-management-tool-for-individuals) ([my answer](http://qr.ae/NQ41Y))
*   [What is the best task management program available online?](http://www.quora.com/What-is-the-best-task-management-program-available-online) ([my answer](http://qr.ae/NQ4GU))

## Reddit

Reddit is a social news website where registered users submit content in the form of either a link or a text post.

They have a [dedicated section to the topic of productivity](http://www.reddit.com/r/productivity). How about you write something about why you find Week Plan useful?

Thank you for your help!

repository: weekplan/www

repo_name: weekplan/www


text:
---
title: "Row"
image: "work/row.gif"
description: "An RPG about building trust with your enemy, inspired by the climate crisis"
---

_Row_

A short narrative RPG that was [submitted](https://itch.io/jam/climate-jam-2022/rate/1511021) to the [IndieCade Climate Jam](https://www.indiecade.com/climate-jam/) and the [Horizons 2022 Grand Challenge](https://www.indiecade.com/horizons-2022-grand-challenge/). It’s a game about two enemies learning to trust one another as they fight for survival in a near-future climate dystopia. The game won the [grand jury award](https://itch.io/jam/climate-jam-2022/rate/1511021) (the top award) at the IndieCade Climate Jam.

It was made in collaboration with students from USC's School of Cinematic Arts, NYU's Tisch School of the Arts, University of Waterloo, and University of Toronto. I was primarily involved in game and narrative design, as well as being one of two programmers.

You can [play the game on itch.io](https://beagle-studios.itch.io/row) with a desktop computer. You can also subscribe to our mailing list on the [website of our studio](https://www.beaglestudios.net/), Beagle Studios.

repository: bennmcgregor/Personal-Website

repo_name: bennmcgregor/Personal-Website


text:
# Doratomyces phillipsii (Berk. & Leight.) F.J. Morton & G. Sm., 1963 SPECIES

#### Status
SYNONYM

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

#### Published in
Mycol. Pap. 86: 82 (1963)

#### Original name
Periconia phillipsii Berk. & Leight., 1875

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Ascomycota/Leightoniomyces/Leightoniomyces phillipsii/ Syn. Doratomyces phillipsii/README.md

repo_name: mdoering/backbone


text:
---
title: SubscriptionOverviewUsage
---
## SubscriptionOverviewUsage

## Properties

|Name | Type | Description | Notes|
|------------ | ------------- | ------------- | -------------|
| **name** | **str** | Product charge name | |
| **part_number** | **str** | Product part number | |
| **grouping** | **str** | UI grouping key | |
| **unit_of_measure_type** | **str** | UI unit of measure | |
| **usage_quantity** | **str** | Usage count for specified period | |
| **overage_price** | **str** | Price for usage / overage charge | [optional] |
| **prepay_quantity** | **str** | Items prepaid for specified period | |
| **prepay_price** | **str** | Price for prepay charge | [optional] |
| **usage_notes** | **str** | Notes about the usage/charge item | [optional] |
| **is_cancellable** | **bool** | Indicates whether the item is cancellable | [optional] |
| **bundle_quantity** | **str** | Quantity multiplier for this charge | [optional] |
| **is_third_party** | **bool** | A charge from a third party entity | [optional] |
{: class="table table-striped"}


text:
[![Donate](images/donate.png)](https://www.paypal.me/grouchon/5)

# XDT transform task
Visual Studio Team Services Build and Release extension that applies XDT transforms on XML files.

## Usage
Add a new task, select **XDT Transform** from the **Utility** category and configure it as needed.

![XDT Transform parameters](images/task-parameters.png)

Parameters include:
- **Working folder**: the working directory for relative paths. If not specified the default working directory will be used.
- **Transformations**: an absolute or relative comma or newline-separated transformation file rules.

> **Syntax**: {xdt path} => {xml path}[ => {output path}]
>
> - `web.release.config => web.config` will apply _web.release.config_ to _web.config_ and update the file.
> - `xdt\web.release.config => config\web.config => web.config` will apply _xdt\web.release.config_ to _config\web.config_ and save the result in _web.config_.
>
> **Wildcard support**
> - `*.release.config => *.config` will apply all _{filename}.release.config_ files to _{filename}.config_ and update the file.
> - `*.release.config => config\*.config => c:\tmp\*.config` will apply all _{filename}.release.config_ files to _config\\{filename}.config_ and save the result in _c:\tmp\\{filename}.config_.
>
> Transform pattern must start with _*_
> Transform file search is recursive
> Relative paths for source pattern and output pattern are relative to the transform file path.

## Tips
You can use the [XDT transform task](https://marketplace.visualstudio.com/items?itemName=qetza.xdttransform) to inject tokens in your XML based configuration files configured for local development and then use the [Replace Tokens task](https://marketplace.visualstudio.com/items?itemName=qetza.replacetokens) to replace those tokens with variable values:
- create an XDT transformation file containing your tokens
- setup your configuration file with local developement values
- at deployment time
  - inject your tokens in the configuration file by using your transformation file
  - replace tokens in your updated configuration file

## Debug
You can set the variable `system.debug` to `true` to enable the debug logging on the task to help you investigate unexpected behavior of the task.
If you cannot fix your issue, open an issue on the github repo and i'll help you :)

# Release notes
**New in 3.1.0**
- Update VstsTaskSdk to 0.11.0 ([#24](https://github.com/qetza/vsts-xdttransform-task/issues/24)).
- Update Microsoft.Web.XmlTransform.dll to 3.1.0 (contributed by [livioc](https://github.com/livioc))

**New in 3.0.0**
- Add support for wildcard in transformation rules ([#8](https://github.com/qetza/vsts-xdttransform-task/issues/8)) (contributed by [Luuk Sommers](https://github.com/luuksommers))

**New in 2.1.0**
- Add support for comma separator in _Transformations_ parameters.

**New in 2.0.0**
- **Breaking change**: All previous parameters are now merged in a single line using syntax `{xdt path} => {xml path}[ => {output path}]`.
- Add support for multiple transformations.
- Add _Working folder_ parameter for root of relative paths.

**New in 1.0.0**
- Initial release


text:
# Errata for *PETSc for Partial Differential Equations*

Not everything in the book is perfect, so reader-submitted corrections and comments are very much appreciated.  Please submit them through the [issues](https://github.com/bueler/p4pdes/issues)  tab at the [github](https://github.com/bueler/p4pdes) site, or by email to the author at<EMAIL_ADDRESS> Corrections to the example programs themselves will appear as commits in the repository, and then in the [releases](https://github.com/bueler/p4pdes/releases).

The list of errata below shows corrections to the text of the 2nd printing.  That is, these errors exist in both the 1st and 2nd printing.  See [errata for the 1st printing](ERRATA-1stprinting.md) for a list of errors which have been corrected in the 2nd printing.

### Chapter 6

* Page 131: The text after equation (6.4) incorrectly defines triangular matrices.  It should say "where d_{ij} = 0 if i \ne j, l_{ij} = 0 if i < j, and u_{ij} = 0 if i > j."

* Page 134: There should be a comma in the final sentence on this page.

### Chapter 9

* Page 230: Formulas (9.25), (9.26), and (9.27) are all missing a "u" term.  There should be "+u \psi_{pq}" added to the integrand.  The code `phelm.c` itself is correct; see the `IntegrandRef()` function.


text:
# galledanza
Self-installing package to automatically set user defined commands & preferences (aliases, etc...)

![alt text](/doc/MoscowTimes.png) <!-- taken from here: https://www.themoscowtimes.com/2016/12/30/russia-hacker-superpower-a56704 -->

## package installation

This package requires a minimal installation, meant not to change along time and to be very simple to update.

The few steps to setup everything are just the following:

```
git clone https://github.com/andreagalle/.galledanza.git
cd .galledanza
source ./install
```

remember do not `./install` to have it immediately effective. At this point everything is setup, just play around and if you want to update the package you just have to type `update-galledanza` from wherever you are!

## setting up email alerts

1. edit the folllowing `sudo vi /etc/exim4/update-exim4.conf.conf` changing:
  * from `dc_eximconfig_configtype='local'`
  * to   `dc_eximconfig_configtype='internet'`
2. finally launch `su /etc/init.d/exim4 restart`

gha_language: Shell


text:
---
layout: leftnav-page-content
title: Information for Testators
permalink: /wills-registry/info-for-testators/
breadcrumb: Information for Testators
collection_name: wills-registry

---

**1. What is the Wills Registry?**

The Wills Registry, maintained by the Public Trustee, is a confidential registry where testators (people making a will) or their solicitors can deposit information on wills.

**2. What are the fees you charge for depositing or searching for the will information?**

Our fees (including GST) are shown below.

    Item
    Fees

    Depositing Information
    $50.00

    Cost of a Search Application
    $10.00

Payment for the deposit and search of will information must be made online via debit card, credit card or direct debit.

**3. How long will my will information be kept in the Wills Registry?**

The will information will be kept in our system for 120 years from the date of birth of the person making the will.

**4. What type of information is kept by the Wills Registry?**

We keep the following information under the Wills Registry.

* Details of the person making the will i.e. testator.

* Date of the will.

* Details of the person who drew up the will.

* Details of where the will is held.

You do not have to deposit your will with us because we do not keep a copy of the actual will.

**5. Does the Wills Registry keep an actual copy of the will?**

We do not keep the actual will in our registry. You or your representative will keep your will. We also do not accept or keep a photocopy.

**6. Is it compulsory to deposit my will information with the Wills Registry?**

No, it is not compulsory to deposit your will information with us.

**7. Will my will become invalid if I do not deposit my will information with the Wills Registry?**

No, the validity of your will does not depend on whether you have deposited your will information with us or not.

**8. How do I deposit my will information with the Wills Registry?**

You will need to access our online deposit form at [pto.mlaw.gov.sg](/) under eServices to deposit your will information with the Wills Registry.

The Wills Registry will no longer accept hardcopy forms for the deposit of will information after **1 Mar 2014**.

You will need to have your SingPass ready to access our online deposit form. You may apply for your SingPass at [https://www.singpass.gov.sg](https://www.singpass.gov.sg) if you do not have one.

If you are not eligible for a SingPass, you may apply for a log-in ID and password. You can refer to our guide available at [pto.mlaw.gov.sg](/) under “Guides and Forms” on how to apply for a log-in ID and password.

**9. How do I deposit my client’s will information as a lawyer acting for them?**

Your law firm or company may apply for an organisation account with us. With an organisation account, your law firm or company will be able to authorise you to access the online deposit form.

You may refer to our guide available at [pto.mlaw.gov.sg](/){:target="_blank"} under “Guides and Forms” on how to apply for an organization account.

Your law firm or company need not apply for a new organisation account if it has an existing organisation account with us.

**10. How do I use the online system?**

You may refer to our step-by-step guide available at [pto.mlaw.gov.sg](/){:target="_blank"} under “Guides and Forms” on how to use the online system.

**11. I have forgotten to print the receipt and/or transacton summary page. Are you able help to provide a copy of it?**

We are unable to provide a copy of the receipt / summary page. You may wish to do a Will search if you wish to verify your submitted information.

**12. How do I update or amend my existing will record?**

You will have to deposit a new will record with the Wills Registry. The $50 fee for new will deposit shall still apply.

In order to protect the integrity of the information submitted and avoid disputes, we are not able to make any amendment to information on wills submitted to us. You will have to make a new submission of information on the will if you wish to amend any information in the record.

**13. How do I delete my will record from the Wills Registry?**

You need to write in to request for a deletion of your will record. You may send in your request by email or post to:

Public Trustee’s Office

The URA Centre (East Wing)

45 Maxwell Road

#07-11

Singapore 069118

Attention: Wills Registry

**[Contact Us @ OneMinLaw](https://www.mlaw.gov.sg/about-us/contact-us/){:target="_blank"}**

Please attach a copy of your identity card and indicate your contact number in your correspondence with us.

There are no fees involved for the deletion of your will record.

**14. Who will have access to the will information?**

All information deposited with us is strictly confidential. Only the following people may make a search for information related to a will:

a) The person who made the will (if they give us proof of identity) or his solicitor.

b) The solicitor acting for the estate of someone who has died (if they produce the death certificate).

c) The next-of-kin of someone who has died if they produce the death certificate and documents showing their relationship to the person who has died.

d) The donee of a Lasting Power of Attorney (LPA) or a deputy appointed or to be appointed by the Court with powers to manage the testator's property and financial affairs in the event that the testator lacks mental capacity (if they produce the LPA or Court Order/Application)

e) A person who appears to the Public Trustee to have a legitimate interest in the testator’s will or estate.

**15. Why is the search results released to only selected persons?**

The Wills Registry, maintained by the Public Trustee, is a confidential registry. The information deposited with the Wills Registry is protected. For this reason, information at the Registry will only be released to solicitors acting for the testator or his estate and to the next-of-kin upon the death of the testator.

**16. How do I carry out a search on will information with the Wills Registry?**

You will need to access our online search form at [pto.mlaw.gov.sg](/) under eServices.

We will need the following supporting documents.

a) For the person making search on own will record:

* Your NRIC

b) For law firms:

* NRIC of the person who made the will or

* Death certificate of the person who made the will

c) For next-of-kin:

* Death certificate of the person who made the will and

* NRIC of next-of-kin and

* Proof of relationship to the person who made the will (for example, marriage certificate (for spouse) and birth certificate (for parents or children))

d) For donee of a Lasting Power of Attorney (LPA) or a deputy appointed or to be appointed by the Court:

* NRIC of donee or deputy or would-be deputy

* Copy of LPA or Court Order / Application

e) For person with a legitimate interest in the testator's will or estate (Please submit your search request using the next-of-kin option in our eService):

* NRIC of person with a legitimate interest in the testator's will or estate

* Proof of relationship to the person who made the will

* Reasons for wanting to make a search on the testator's will together with the relevant supporting documents. (Please upload your written reasons and supporting documents under the attachment for Death Certificate in our eServices.)

Please allow **3 - 5 working days** for us to process your form.

You will need to have your SingPass ready to access our online deposit form. You may apply for your SingPass at [https://www.singpass.gov.sg](https://www.singpass.gov.sg/spauth/login/loginpage?URL=%2F&TAM_OP=login) if you do not have one.

If you are not eligible for a SingPass, you may apply for a log-in ID and password. You can refer to our guide available at [pto.mlaw.gov.sg](/) under “Guides and Forms” on how to apply for a log-in ID and password.

**17. Do you accept hardcopy forms?**

The Wills Registry no longer accepts hardcopy search forms after **15 April 2014**.

**18. How long do I have to wait for the search results?**

The search results will be sent to you via email within **3 to 5 working days** after we have received your search request.

**19. How will the results be sent to me?**

The search results will be sent to you via **email** once we have verified your supporting documents.

The search results will no longer be sent by post or fax.

Drawing up a Will
---

**1. Can I make a will on my own without seeking the assistance of a solicitor?**

Yes, you can make a will on your own without seeking the assistance of a solicitor. However, please note that a will may be challenged or invalid if it had been drafted improperly or was ambiguous.

**2. How do I make a will on my own?**

The Public Trustee does not provide legal advice on how a will should be made. Since you are unclear about how to make a will on your own, you may consider seeking legal advice from a lawyer.

LSRA has an integrated online search function which lists all registered law practices (foreign or local), Singapore solicitors, foreign lawyers, and regulated non-practitioners. At present, you can search by name, practice area, and the type of law practice. We are working on further enhancements to the search function.

Please note that the search results are based on information provided by law practices and lawyers. The Ministry of Law does not make any warranty or representation as to their accuracy, completeness or reliability.

**3. I am in the midst of drafting my will and would like to include the Public Trustee’s Office as the executor of my will. Please advise if this is possible?**

The Public Trustee does not accept any appointment to act as an executor of a will. You can appoint a family member, friend, an independent professional or a trust company to be the executor of your will.

**4. Where can I make a will at a minimum cost?**

We are unable to advise you on where you can make a will at a minimum cost.

LSRA has an integrated online search function which lists all registered law practices (foreign or local), Singapore solicitors, foreign lawyers, and regulated non-practitioners. At present, you can search by name, practice area, and the type of law practice. We are working on further enhancements to the search function.

Please note that the search results are based on information provided by law practices and lawyers. The Ministry of Law does not make any warranty or representation as to their accuracy, completeness or reliability.

**5. Does the Wills Registry provide help in drafting a will?**

We do not provide legal advice on drafting a will or how the will is to be executed. You may want to contact a solicitor for help with drafting a will.


text:
# Pazy Wing Analysis on SHARPy

Contains scripts for the generation of simulations on the Pazy wing using SHARPy as part of the 3rd Aeroelastic Prediction Workshow (AePW3).

The results are archived in a results specific [repository](http://github.com/ngoiz/pazy-aepw3-results).

This repositiory contains:
  * Simulation and postprocessing scripts
  * A library of required, version controlled submodules of:
      * The SHARPy model of the Pazy wing
      * The appropriate SHARPy version
      * SHARPy postprocessing tools

repository: ngoiz/pazy-sharpy

repo_name: ngoiz/pazy-sharpy


text:
# EmberFire Changelog

### EmberFire 1.0.4 (April 4, 2014)

* _saveHasManyRelationshipRecord bug fix

### EmberFire 1.0.3 (April 1, 2014)

* Added conditional in `find()` to verify that a record can be deleted
* Misc cleanup

### EmberFire 1.0.2 (April 1, 2014)

* Added a `_queue` to batch realtime updates and decrease `Ember.run` calls
* Refactored tests using Mocha
* General cleanup/reorganization

### EmberFire 1.0.1 (March 26, 2014)

* Added support for embedded records
* Setting the ApplicationSerializer is no longer required
* Added unit tests

### EmberFire 1.0.0 (March 24, 2014)

* Added DS.FirebaseAdapter and DS.FirebaseSerializer
* Removed EmberFire.Object and EmberFire.Array

### EmberFire 0.0.1 (September 24, 2013)

* Alpha version of `EmberFire.Object` and `EmberFire.Array`

repository: jrhe/emberFire

repo_name: jrhe/emberFire


text:
# PSB
A bot to scan local LAN for a whitelist of macs to report presence. Based off http://blog.initialstate.com/know-whos-at-the-office-with-the-raspberry-pi/ but designed to work (initially) with slack instead of Initial State. Work in progess

## Incomplete list of projects used
- https://github.com/ThomasHabets/arping
- https://github.com/royhills/arp-scan
- https://github.com/slackapi/python-slackclient

repository: aarro/psb

repo_name: aarro/psb


text:
# Symlinked Directories [![Build Status](https://travis-ci.org/GooseStudio/symlinked-extensions.svg?branch=master)](https://travis-ci.org/GooseStudio/symlinked-extensions)
Simple script that replaces a directory with a symlink. If the targeted directory does not exist symlink is still created.
The symlink paths directory name is matched against the directories in the chosen target path.

Add below config to composer.json to run the script.
```
    "post-update-cmd": ["php vendor/bin/linkit"]
```

### Example linkit.json

```
{
  "mu-plugins": {
    "target": "/web/app/mu-plugins/",
    "src": [
        "/home/projects/wordpress/my-plugin"
    ]
  },
  "plugins": {
    "target": "/web/app/plugins/",
    "src": [
        "/home/projects/wordpress/my-plugin",
        "/home/projects/wordpress/my-plugin2"
    ]
  },
  "themes": {
    "target": "/web/app/themes/",
    "src": [
        "/home/projects/wordpress/my-theme"
    ]
  }
}
```

### Arguments

* **--test** runs the script but without removing directories or symlinking
* **--no-dev** excludes the script from running if "--no-dev" param is used in composer install/update.
* **--linkit=full_path_to_json_file** use specified file as config.
* **--hide** Do not print commands
* **--keep** Do not remove existing folders, postfixes with number of folders.

repository: GooseStudio/symlinked-extensions

repo_name: GooseStudio/symlinked-extensions


text:
# DDPG
Deep Deterministic Policy Gradient Algorithm for BipedalWalker OpenAI Gym environment

Implemented using:
Tensorflow
Keras
OpenAI gym
Numpy

Trained on Google Collaboratory platform

repository: kavitawagh/DDPG

repo_name: kavitawagh/DDPG


text:
---
title: "Palladium-Catalyzed Insertion of an Allene into an Aminal:
  Aminomethylamination of Allenes by C-N Bond Activation"
publication_types:
  - "2"
authors:
  - Jianhua Hu
  - Yinjun Xie
  - Hanmin Huang
doi: 10.1002/anie.201403774
publication: Angewandte Chemie International Edition
abstract: A new and atom-economic palladium-catalyzed aminomethylamination of
  allenes with aminals by CN bond activation is described. This direct and
  operationally simple method provides a fundamentally novel approach for the
  synthesis of 1,3-diamines. Mechanistic studies suggest that a unique cationic
  π-allylpalladium complex containing an aminomethyl moiety is generated as a
  key intermediate through the carbopalladation of the allene with a
  cyclometalated palladium–alkyl species.
draft: false
featured: false
image:
  filename: featured
  focal_point: Smart
  preview_only: false
date: 2014-05-30T12:45:49.503Z
---


text:
# Authors and Contributors

This dataset is presented in our CVPR 2015 paper, Linjie Yang, Ping Luo, Chen Change Loy, Xiaoou Tang. A Large-Scale Car Dataset for Fine-Grained Categorization and  Verification, In Computer Vision and Pattern Recognition (CVPR), 2015.

# Functionality

The Comprehensive Cars (CompCars) dataset contains data from two scenarios, including images from web-nature and surveillance-nature. The web-nature data contains 163 car makes with 1,716 car models.  The full car images are labeled with bounding boxes and viewpoints. Each car model is labeled with five attributes, including maximum speed, displacement, number of doors, number of seats, and type of car. The surveillance-nature data contains 50,000 car images captured in the front view. Please refer to our paper for the details.
The train/test subsets of these tasks introduced in our paper are included in the dataset. Researchers are also welcome to utilize it for any other tasks such as image ranking, multi-task learning, and 3D reconstruction.

## Input

A colour (224x224) image of a car.

## Output

The most likely type of car, for the given input.

## License

MIT.

repository: charankumarpalla/Awesome-ML

path: /Awesome ML/CoreML Models/Image Processing Models/CarRecognition/Detailed Description/CarRecognition.md

repo_name: charankumarpalla/Awesome-ML