text:
<!--
.. link:
.. description:
.. tags: Christianity, Religion and Spirituality
.. date: 2014/11/18 16:57:21
.. spellcheck_exceptions: ourself
.. title: Bible studies - a simple template
.. slug: bible-studies-a-simple-template
-->

Recently, a colleague and I started a bible study at work. While I've been a part of christian small-groups for quite some time, I've not been in one that has a focus on bible study, so I was looking for suggestions on how to do it well. I had a friend suggest this pair of questions to ask, after reading a passage of scripture:

1. What is God saying to you?
2. What is God saying about himself?

I like the former because it encourages us to apply God's word to our life *(But don't just listen to God's word. You must do what it says. Otherwise, you are only fooling yourselves - James 1:22)*. I like the latter because it's so easy to focus on ourself and forget that the Bible is here to teach us about God, not just to help us understand ourselves. It's simple and thought-provoking approach that I thought was worth sharing.

gha_language: Python


text:
---
title: 'Creation and Evolution – My View'
author: bsoist
layout: post
pdrp_attributionLocation:
  - end
dsq_thread_id:
  - 724145116
categories:
  - faith
tags:
  - Creation
  - Science and Religion
---
About a month ago, [I decided][1] to start a regular post on the topic of science and religion, and I thought it made sense to start with a series about creation and evolution.

I know that sharing my opinions at this stage might take away from an objective review of the issues as we move forward, but I also think that some might benefit from knowing where I stand on the issues right up front.

As I think I [have made clear already][2], my opinion on these matter may change over time, but as of this moment, this is what I believe …

  * I believe in God, because I do. I don’t think the evidence for His existence is sufficient to believe. I simply believe.
  * I believe the [Scriptures are inspired by God Himself][3].
  * I believe [nature is also God’s revelation][2].
  * I believe God created the universe approximately 14 billion years ago.
  * I believe the events described in Genesis 1:2 immediately followed the events described in Genesis 1:1.
  * I believe in the Big Bang – the universe started in an extremely hot and dense state, some 14 billion years ago, and that it has been expanding ever since.
  * I believe that the days of creation are chronological.
  * I believe that the durations of each day are not necessarily equal, and that they represent very long periods of time (millions and millions of years).
  * I believe that galaxies and solar systems formed over billions of years. I accept astronomical evolution.
  * I believe the current geology of the Earth is a result of billions of years of geological evolution.
  * I believe the Earth was seeded with life intentionally by God. He may have chosen to do so via fiat, or chemical evolution may have played a part. I have no idea.
  * I believe [atheism is not a prerequisite to believing in evolution][4]
  * I believe there is overwhelming evidence for biological evolution.
  * I operate under the assumption that all life on Earth evolved from a common ancestor.
  * I think the fossil record supports either special creation by God at different times during the history of Earth, or in some kind of non-Darwinian evolution from one species to another.

I think those last three points deserves some explanation. I have no philosophical or theological bias against biological evidence. As a matter of fact, I agree with Charles Darwin’s view of this idea.

> There is grandeur in this view of life, with its several powers, having been originally breathed by the Creator into a few forms or into one; and that, whilst this planet has gone cycling on according to the fixed law of gravity, from so simple a beginning endless forms most beautiful and most wonderful have been, and are being evolved.

My area of interest is cosmology, astrophysics, and theology. I have read extensively on the theory of biological evolution, but mostly from a philosophical standpoint. I simply do not have the expertise in biology to make an informed decision. I have also studied Scripture for many years, but I don’t know enough to say for sure whether I think God uses biological evolution as a means for creation. I would have no problem with it if He did, I just simply don’t know.

Labels

For those of you who would prefer I label myself in terms of the current debate …

  * I reject the supposed physical evidence of a young earth as pseudoscience.
  * I think organizations like Answers in Genesis and the Institute for Creation Research spread misinformation and lies.
  * I reject “flood geology” as pseudoscience.
  * I think “Creation Science” is not science at all.
  * I think [intelligent design is not science][5].
  * I subscribe to some kind of old earth creationism – probably progressive creationism, but I don’t rule out theistic evolution (in fact, as mentioned above, I rather like the idea)
  * I reject the gap theory and hold to a “day age” view of Genesis chapter one, though I have no theological opposition to suggestions that the days of creation represent days of revelation instead of the actual days of creation.

 [1]: http://whsjr.soistmann.com/oped/2012/05/07/science-and-religion/
 [2]: http://whsjr.soistmann.com/oped/2012/05/23/special-revelation-vs-natural-revelation/
 [3]: http://whsjr.soistmann.com/oped/2012/05/17/inerrancy-and-infallibility/
 [4]: http://whsjr.soistmann.com/oped/2011/01/05/i-want-my-99-cents-back/
 [5]: http://whsjr.soistmann.com/oped/2009/10/19/is-intelligent-design-science/

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
---
layout: article
title: "A Wizard's Lizard by the numbers: our HTML5 game on Steam"
author: matt
---

[A Wizard's Lizard][1] is an action roguelike where players control a pet lizard, made by a small, independent game studio in California called [Lost Decade Games][2]. Our mission was to make a solid desktop game that would pave the way for our next project, and help our studio thrive. Let's examine the numbers to see how we did.

## Kickstarter

We first [Kickstarted the project as Crypt Run][3] in July 2013, earning $9,013 during its 30-day funding period. Part of the campaign's success is likely due to our [live demo at California Extreme][4], an annual arcade and pinball expo.

During the funding campaign, we met Greg Love of [Whippering][5] and started working together on marketing and business development. Greg has been a huge help with marketing, press and [YouTube][9] outreach, as well as general consultation. (He even [presented a talk][13] about the business behind the launch, with even more lovely charts and numbers!)

Around this time we also decided to [change the name][6] of the game from Crypt Run to A Wizard's Lizard. We agonized over this decision, but ultimately felt it was best, as it made the game much more [memorable][10] and helped introduce a compelling main character.

## Steam Greenlight and Humble

On January 8th we launched our [Steam Greenlight campaign][7], which was successful on February 19th. Some of our developer friends have had games on Greenlight for more than a year, so we feel really grateful that we were able to move through this painful process quickly. Many votes came from the gaming communities of Twitch streamers [CobaltStreak][11] and [Lethalfrag][12]. If not for them, who knows? Maybe we'd still be slowly crawling up the Greenlight charts.

On January 22nd, we launched A Wizard's Lizard on our own [website][1] with a Humble widget, selling 516 copies in the first month. From the Humble launch up until the Steam launch, we sold 859 copies.

## Steam launch

A Wizard's Lizard [launched on Steam][8] June 16th, at $14.99, but this time with a 34% launch discount (actual price: $9.89). As does any new game on Steam, we received homepage placement, a valuable and coveted position. Fortunately, we were able to stay above the average conversion rate, so our time on the homepage was extended by about 40x what we would have received if our game was not performing well.

A large part of our initial launch success is due to the wonderful YouTuber and Twitch communities, especially Northernlion who did a [series on A Wizard's Lizard](https://www.youtube.com/playlist?list=PL1bauNEiHIgzILSj4Z4yECli8SUyjaiRv). Video content creators are probably the primary way games discover our game, so we're really grateful for coverage. In the first 72 hours on Steam, we sold 6,340 copies. And then...

## Steam Summer Sale

The Steam Summer Sale made us really nervous: would our new, small game disappear in the vast ocean of prolific games with deep discounts? The massive Steam sale began Thursday, June 19th, just three days after our launch.

Immediately we started off on the wrong foot -- we set "34%" for our Steam Summer Sale discount, the same as our launch sale. Our thinking was we'd just continue with the launch sale through the SSS. But nope! The discounts stack, and so A Wizard's Lizard was 68% off for a short period, causing some unhappy tweets from early supporters.

We brought the discount back down to 34% as intended within one hour, during which we moved 528 units. Previous to that spike, our hourly high was 428 units right at launch!

During the Steam Summer Sale we sold 5,834 copies in total. It's tough to say if we would have moved more units if SSS hadn't taken place so soon after our launch, but our conversion rate was slipping, so we likely wouldn't have had homepage placement for much longer anyway.

In our first week on Steam, we sold 8,344 units. The excitement over the Steam launch also brought in additional Humble interest, netting another 541 sales during that week on Humble.

## Our own Steam sale

Well before launch we had plans to update AWL with bug fixes and additional Steam features (trading cards are in the works!). We also wanted to add new content, which we used to couple with a sale. With this new content and another 34% discount, we brought in another 615 sales in one week.

As you can see, our ability to drive our own traffic is minimal compared to Steam's massive audience. It took us a week to drive a few more sales than our 68% discount during SSS made in just one hour!

## Totals

From January 22nd to the writing of this article, we've sold a grand total of 14,719 copies of A Wizard's Lizard. Here is a breakdown of where those sales came from.

* Steam: 12,671
* Humble: 1,739
* Kickstarter: 309
* Total: 14,719

## What's next?

There will probably be another Steam Winter Sale, and as you saw above, Steam accounts for 86% of our sales, so you bet we'll participate if we can! We also hope to drive more interest with even more content, such as a Halloween-themed boss encounter, but our ability to continue work on the game depends on how it performs in the market.

I believe if nothing else our experience confirms what we've heard from other indies, which is that [Steam][14] is the place for desktop games to be. Hopefully this information will help other developers out there. We also share this kind of information on our [podcast][15] and on [Twitter][16], if those sorts of things interest you. Game on!

[1]: http://www.wizardslizard.com/
[2]: http://www.lostdecadegames.com/about/
[3]: https://www.kickstarter.com/projects/richtaur/crypt-run-death-is-just-the-beginning
[4]: http://www.lostdecadegames.com/cax-2013-photos/
[5]: http://whippering.com/
[6]: https://www.kickstarter.com/projects/richtaur/crypt-run-death-is-just-the-beginning/posts/636785
[7]: http://steamcommunity.com/sharedfiles/filedetails/?id=205801629
[8]: http://steamcommunity.com/games/280040/announcements/detail/1516899696886115886
[9]: https://www.youtube.com/user/lostdecadegames
[10]: https://twitter.com/SusanArendt/status/421697245021765632
[11]: http://www.twitch.tv/cobaltstreak
[12]: http://www.twitch.tv/lethalfrag
[13]: http://blog.whippering.com/post/89985226380/the-launch-of-a-wizards-lizard
[14]: http://store.steampowered.com/app/280040/
[15]: http://www.lostdecadegames.com/lostcast/
[16]: https://twitter.com/LostDecadeGames

repository: lostdecade/manor

repo_name: lostdecade/manor


text:
# Whatsapp-mass-messaging-Python

![GitHub followers](https://img.shields.io/github/followers/Rishit-dagli?label=Follow&style=social)
[![Twitter](https://img.shields.io/twitter/url?style=social&url=https%3A%2F%2Fgithub.com%2FRishit-dagli%2Fpopup_box)](https://twitter.com/intent/tweet?text=Wow:&url=https://github.com/Rishit-dagli/Whatsapp-mass-messaging-Python/)
![Twitter Follow](https://img.shields.io/twitter/follow/rishit_dagli?label=Follow&style=social)

A python code which uses web automation to send mass whatsapp messages to people without having to save the phone numbers which are provided in csv file.
## Versions availaible

* **1.0.0** - The message_text, no_of_message, mobile_no_list variables where they have their usual meaning are hardcoded or ecplicitly defined in the code.
* **1.1.0** - The code is modified so the number of mobile numbers are extracted from the csv file "test_numbers.csv".
* **1.2.0** - The code is modified so the number of mobile numbers are extracted from the csv file "test_numbers.csv" and message is too extraccted from a text file.
  The code can take the message in all different languages, for demonstration I have named the file "hindi_message.txt".

To extract the numbers use the code:

```
with open('test_numbers.csv', 'r') as csvfile:
  moblie_no_list = [int(row[0])
    for row in csv.reader(csvfile, delimiter=';')]
# get mobile no from csv file
```

For extracting the text use code:

```py
with open('hindi_message.txt') as hindi_file:
  for text in hindi_file:
      message_text+=text
```


text:
# Make Error Cause

[![NPM version][npm-image]][npm-url]
[![NPM downloads][downloads-image]][downloads-url]
[![Build status][travis-image]][travis-url]
[![Test coverage][coveralls-image]][coveralls-url]

> Make your own nested error types!

## Features

* Compatible with Node and browsers
* Works with `instanceof`
* Use `error.stack` and `error.name`
* Output full cause with `toString`
* Extends [make-error](https://github.com/julien-f/js-make-error)

## Installation

```sh
npm install make-error-cause --save
```

## Usage

Usages from [`make-error`](https://github.com/julien-f/js-make-error#usage). The only difference is that errors accept a second argument known as the error "cause". The cause is used to wrap original errors with more intuitive feedback - for instance, wrapping a raw database error in a HTTP error.

```js
const CustomError = makeErrorCause('CustomError')

const cause = new Error('boom!')
const error = new CustomError('something bad', cause)

error.toString() //=> "CustomError: something bad\nCaused by: boom!"
error.stack // Works!
error.cause.stack // Handy!
```

## Attribution

Inspired by [`verror`](https://www.npmjs.com/package/verror), and others, but created lighter and without core dependencies for browser usage.

## License

Apache 2.0

[npm-image]: https://img.shields.io/npm/v/make-error-cause.svg?style=flat
[npm-url]: https://npmjs.org/package/make-error-cause
[downloads-image]: https://img.shields.io/npm/dm/make-error-cause.svg?style=flat
[downloads-url]: https://npmjs.org/package/make-error-cause
[travis-image]: https://img.shields.io/travis/blakeembrey/make-error-cause.svg?style=flat
[travis-url]: https://travis-ci.org/blakeembrey/make-error-cause
[coveralls-image]: https://img.shields.io/coveralls/blakeembrey/make-error-cause.svg?style=flat
[coveralls-url]: https://coveralls.io/r/blakeembrey/make-error-cause?branch=master

repository: rahulpnath/Blog

gha_language: JavaScript

gha_license_id: MIT

repo_name: rahulpnath/Blog


text:
## Kubernetes

### Add Autocomplete for Bash

#### Linux

Install Bash Completion (e.g. yum -y install bash-completion or apt-get install bash-completion)

```
cd /etc/bash_completion.d/
kubectl completion bash  > kubectl
. .bashrc
```

### Watch Command

The linux watch command when running kubectl get pods doesn't work well.  Adding a clear redirected to /dev/null provides a clean output.

```
watch -n 5 "clear > /dev/null ;kubectl -n kube-system get pods"
```

### Delete Pods in Completed or Error Status

```
kubectl delete pod $(kubectl get pods | grep " Completed " | cut -d" " -f 1)
```

```
kubectl delete pod $(kubectl get pods | grep " Error " | cut -d " " -f 1)
```

### Delete all pvc's

```
kubectl delete pvc $(kubectl get pvc -o custom-columns=NAME:.metadata.name --no-headers)
```

### Resize PVC

The Storage Class needs to include

```
allowVolumeExpanstion: true
```

The Storage Backend also need to support this option.

Tried to create a custom storage class using Azure default and managed-premium that included this parameter; however, I still could not resize the pvc.

Added the parameter to Portworx StorageClass.  After making this change the pvc could be resized.

```
kubectl edit pvc datastore-elasticsearch-client-0
```

Changed the size (e.g. 100Gi to 200Gi).

After a few seconds the Volume changed.


text:
---
title: Opcode Save
searchTitle: Lua Opcode Save
weight: 1
hidden: true
menuTitle: Opcode Save
---
## Save

This represents a Save opcode
```lua
Opcode.Save
```

repository: xackery/eqquestapi

repo_name: xackery/eqquestapi


text:
# Olimijada-by-Summanus
Node.js + Angular 5 + SQLite3 + Angular Material project.

## DEMO ##

Access info:

Username: summanus

Password: Sarma?1418

Welcome page: http://<IP_ADDRESS>:11000/

You can register!
User portal: http://<IP_ADDRESS>:11002

Admin Login:

Username: admin

Password: aDmIn?1312

Admin portal: http://<IP_ADDRESS>:11001/

## About ##

Web application designed for learning AI. Project contains three parts, OlimijadaTV - part where simulations are displayed, User portal - interface for users and Admin portal - interface for managing settings in User app. This is the first large project where I worked in a team.

Technologies: NodeJS, Angular 5, SQLite3, Angular Material

This repository contains all files from Olimijada projects on SVN.

## Screenshots ##

### User portal ###

[![Screen Shot](https://i.imgur.com/8lh90y4.png)](#)

'Home page' (only front end validation)

[![Screen Shot](https://i.imgur.com/pxa4nsK.png)](#)

Login screen

[![Screen Shot](https://i.imgur.com/oyH2MUB.png)](#)

Olimijada TV

[![Screen Shot](https://i.imgur.com/gytvnZf.png)](#)

List of games

[![Screen Shot](https://i.imgur.com/DaP42gE.png)](#)

Tournaments

[![Screen Shot](https://i.imgur.com/Ztafggs.png)](#)

Matches

[![Screen Shot](https://i.imgur.com/UWb9soV.png)](#)

Players

[![Screen Shot](https://i.imgur.com/SsZgS1K.png)](#)

User menu

[![Screen Shot](https://i.imgur.com/Y5Ghsim.png)](#)

Dark mode

[![Screen Shot](https://i.imgur.com/CqCA2BU.png)](#)

Teams

[![Screen Shot](https://i.imgur.com/T1vtNQi.png)](#)

Profile

[![Screen Shot](https://i.imgur.com/X9AAL44.png)](#)

Football match

[![Screen Shot](https://i.imgur.com/CNYUdOD.png)](#)

Connected 4 game

[![Screen Shot](https://i.imgur.com/xIjwEHn.png)](#)

Basketball match

[![Screen Shot](https://i.imgur.com/CqPp9yQ.png)](#)

Tic Tac Toe match

### Admin page ###

[![Screen Shot](https://i.imgur.com/1fNUTSw.png)](#)

Admin page login page

[![Screen Shot](https://i.imgur.com/j0hlqw0.png)](#)

Dashboard

[![Screen Shot](https://i.imgur.com/MEhdDjb.png)](#)

Tournaments

## Licence

Source code can be found on [github](https://github.com/georgeOsdDev/markdown-edit), licenced under [MIT](http://opensource.org/licenses/mit-license.php).

Developed by [Jelena Colic](https://github.com/jelenacolic), Nikola Pajovic, David Anicic and [Bokunda](https://github.com/bokunda).
© 2018.

repository: David-Anicic/Olimijada

repo_name: David-Anicic/Olimijada


text:
# New
I've just created 2 new classes which are cleaner and easier-to-follow than older code. Also 2 tests for those classes.

# Requirements
- `pip install pyqtgraph`
- `shape_predictor_5_face_landmarks.dat` and `shape_predictor_68_face_landmarks.dat` in the same folder.

# Implementation
- run `python test_signal_processing.py` because it has every thing you need :)

Inside the `data.txt`
  ```
  time: 1.3335 , HR: 89.99
  time: 1.3668 , HR: 87.80
  time: 1.4001 , HR: 85.71
  time: 1.4335 , HR: 83.71
  time: 1.4668 , HR: 81.81
  time: 1.5001 , HR: 79.99
  time: 1.5335 , HR: 78.25
  time: 1.5668 , HR: 76.59
  time: 1.6002 , HR: 74.99
  time: 1.6335 , HR: 73.46
  time: 1.6668 , HR: 71.99
  ```


text:
# SmartMenus

Advanced jQuery website menu plugin. Mobile first, responsive and accessible list-based website menus that work on all devices.
Check out [the demo page](http://vadikom.github.io/smartmenus/src/demo/).

## Quick start

- [Download the latest release](http://www.smartmenus.org/download/).
- Install with [Bower](http://bower.io): `bower install smartmenus`.
- Install with [npm](https://www.npmjs.com): `npm install smartmenus`.
- Clone the repo: `git clone https://github.com/vadikom/smartmenus.git`.

Check out the [project documentation](http://www.smartmenus.org/docs/) for quick setup instructions, API reference, tutorials and more.

## Addons usage as modules
If you need to use any of the addons from the "addons" directory as an AMD or CommonJS module:

### AMD
Make sure your SmartMenus jQuery plugin module is named `smartmenus` since the addons require that name. For example, in RequireJS you may need to add this in your config:
```javascript
requirejs.config({
  "paths": {
    'smartmenus': 'jquery.smartmenus.min'
  }
  // ...
```

### CommonJS (npm)
The addons are available as separate npm packages so you could properly install/require them in your project in addition to `jquery` and `smartmenus`:

- Bootstrap 4 Addon: `npm install smartmenus-bootstrap-4`

- Bootstrap Addon: `npm install smartmenus-bootstrap`

- Keyboard Addon: `npm install smartmenus-keyboard`

#### Example with npm + Browserify

package.json:
```javascript
{
  "name": "myapp-using-smartmenus",
  "version": "1.0.0",
  "license": "MIT",
  "dependencies": {
    "jquery": ">=2.1.3",
    "smartmenus": ">=1.1.0",
    "smartmenus-keyboard": ">=0.4.0"
  },
  "devDependencies": {
    "browserify": ">=9.0.3"
  }
}
```

entry.js:
```javascript
var jQuery = require('jquery');
require('smartmenus');
require('smartmenus-keyboard');

jQuery(function() {
  jQuery('#main-menu').smartmenus();
});
```

Run browserify to create bundle.js: `browserify entry.js > bundle.js`

## Homepage

<http://www.smartmenus.org/>

## Documentation

<http://www.smartmenus.org/docs/>

## Community and support

- Visit the [Community forums](http://www.smartmenus.org/forums/) for free support.
- [Premium support](http://www.smartmenus.org/support/premium-support/) is also available.
- Read and subscribe to [the project blog](http://www.smartmenus.org/blog/).
- Follow [@vadikom on Twitter](http://twitter.com/vadikom).

## Bugs and issues

For bugs and issues only please. For support requests please use the [Community forums](http://www.smartmenus.org/forums/) or contact us directly via our [Premium support](http://www.smartmenus.org/support/premium-support/).

<https://github.com/vadikom/smartmenus/issues>

repository: vadikom/smartmenus

gha_language: HTML

repo_name: vadikom/smartmenus


text:
---
title: Checking health of sources
weight: 2
---

Checking the health of a source is done by `SourceHealthCheck` classes configured in the `monitor.source_health_checks` key of the `backup-server` config file.

The package ships with these two checks configured by default:
- `MaximumStorageInMB`: this check will fail if the total size of your backups is greater that the specified amount of megabytes. You can override the the maximum amount of megabytes in the config file by filling the `healthy_maximum_storage_in_mb` attribute on a `Destination`. You can override that value defined on a `Destination` by settings the `healthy_maximum_storage_in_mb` on a source.
- `MaximumAgeInDays`: this check will fail if the age of the youngest back is older than the given amount of days. You can override the the agi in the days in the config file by filling the `healthy_maximum_backup_age_in_days` attribute on a `Destination`. You can override that value defined on a `Destination` by settings the `healthy_maximum_backup_age_in_days` on a source.

## Creating health checks of your own

In the `monitor.source_health_checks` key of the `backup-server` config file you can add health check classes of your own. Any class you add there should extend `Spatie\BackupServer\Tasks\Monitor\HealthChecks\Source\SourceHealthCheck`. Here is how that abstract class is defined.

```php
namespace Spatie\BackupServer\Tasks\Monitor\HealthChecks\Source;

use Spatie\BackupServer\Models\Source;
use Spatie\BackupServer\Tasks\Monitor\HealthCheckResult;
use Spatie\BackupServer\Tasks\Monitor\HealthChecks\HealthCheck;

abstract class SourceHealthCheck extends HealthCheck
{
    abstract public function getResult(Source $source): HealthCheckResult;
}
```

## Get notifications of (un)healthy sources

You can receive notifications when the monitor finds an (un)healthy sources.
Read the section on [notifications](TODO: add link) to learn more.

repository: ViningWebstyle/laravel-backup-server

repo_name: ViningWebstyle/laravel-backup-server


text:
# spring-app-monitoring
Monitor Spring apps

## Capture metrics and health of the application and expose metrics which can be visualized using visualization tool

# How to run the application

1. sh ./start.sh
   This will create three docker containers , one for application, one for prometheus and one for grafana.

   i. app-monitor
   ii. monitoring_prometheus
   iii. monitoring_grafana

Once the application is up , you can check the status by visiting this url http://localhost:8061/

Now we can go to prometheus and check if the target is setup and is ready.

Go to http://localhost:9090/targets/ , you should see a target status as up with url (http://app-monitor:8061/)

Now we have to go to Grafana and add a dashboard to start visualizing the stats.

Go to http://localhost:3000 , login using admin/admin.

Add this dashboard is already there you will have to use import option. https://grafana.com/grafana/dashboards/4701

Now you can see the application status.

Let's run some test and see the graphs.

1. http://localhost:8061/loadfile/small
2. http://localhost:8061/loadfile/large
3. http://localhost:8061/loadfile/camel/small
4. http://localhost:8061/loadfile/camel/large

You can click on each link , this will in turn load a csv file in embedded nitrate DB. You can monitor the stats.

# How to stop the application

1. sh ./stop.sh

repository: vgaur/spring-app-monitoring

repo_name: vgaur/spring-app-monitoring


text:
# Image manipuliation tools

## Commandline tools

* [Imagemagick](https://imagemagick.org/index.php) is a cross platform tool for image processing.

```Bash
# Installation on Ubuntu
result=$(apt list --installed | grep -i 'imagemagick'| awk -F '/' '{ print $1 }' | head -n 1)

if [[ -z $result ]]
then
  sudo apt install imagemagick -y
fi
```

On windows 10, you could use this tool using **windows subsystem for linux** or natively install it.


text:
# `nbsearch`
Datasette based notebook search extension, originally inspired by Simon Willison's [Fast Autocomplete Search for Your Website](https://24ways.org/2018/fast-autocomplete-search-for-your-website/).

[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/ouseful-testing/nbsearch/main)

## Installation

`pip3 install --upgrade git+https://github.com/ouseful-testing/nbsearch.git`

## Usage

*This is still very much a work in progress.*

### From the command line

- create a database by passing a path to some notebook files, eg:
  - `nbsearch index -p "/Users/myuser/Documents/content/notebooks"`
- run the server, eg:
  -  `nbsearch serve`

`datasette` should start up and display a server port number.

## UI

![](.images/nbsearch.png)

## Know Issues

The links to notebooks may well be broken: I need to think about how to index and handle paths in links, particular in proxy server case.

Not tried: the `jupyter-server-proxy` version (bits of code are in place, but more fettling may still be required before it even runs, let alone works...)

The db should probably be placed somewhere out of the way; could we even keep it in the Python static file area?

MyBinder hates the repo for some reason? `Could not resolve ref for gh:ouseful-testing/nbsearch/master. Double check your URL.`

repository: chekos/nbsearch

branch_name: refs/heads/main

repo_name: chekos/nbsearch


text:
# MetaGETA

Note: this project is no longer maintained.

Search for, extract and transform metadata from spatial imagery data.

## Introduction
MetaGETA is a python application for discovering and extracting metadata from spatial raster datasets (metadata crawler) and transforming it into xml (metadata transformation). A number of generic and specialised imagery formats are supported. The format support has a plugin architecture and more formats can easily be added.

## News
**Coming soon**
<!--

-->

## Features
 - Search for supported data formats on your local or network file system;
 - Automatically extract file and format specific metadata;
 - Automatically populate an MS Excel (.xlsx) file with the metadata;
 - Automatically generate quicklooks and thumbnails for each metadata record;
 - Manually supplement metadata records with additional metadata fields;
 - Transform the MS Excel file to ANZLIC profile ISO19115/19139 xml as a bundled (includes quicklooks and thumbnails)
   MEF suitable for upload to Geonetwork;
   - Note: You can write your own translation stylesheet to meet the requirements of your target profile.
 - Subsequent metadata crawls may be used to update records when data is added to or removed from the file system;
 - Enables flagging of records in MS Excel that should not be included in the transformed xml i.e. maintains a record
   of but does not create xml metadata for redundant or irrelevant datasets.

## Installation
**Coming soon**
<!--
MetaGETA is available on pypi, or from the GitHub [release page](https://github.com/lpinner/metageta/releases).

User installation:

    pip install --user metageta
    pip install --user <path_to_downloaded_metageta>.whl

System wide installation (requires root/admin/elevated privileges):

    pip install metageta
    pip install <path_to_downloaded_metageta>.whl

Windows users may optionally use the executable installers which also add Start Menu shortcuts for the runcrawler and
runtransform scripts and a Windows Explorer folder/directory context menu to allow you to right click a folder and run
the runcrawler script on that folder.

-->

### Requirements
[Python 2.7](https://www.python.org/downloads/release) and the following 3rd party Python libraries:

 - lxml
 - openpyxl
 - pypiwin32 (obviously only on Windows)
 - gdal>=1.7

### Notes for Windows users:
PyWin32, GDAL and lxml are binary extensions.  While [PyPi](https://pypi.python.org) has prebuilt
wheels for PyWin32 (pypiwin32) and lxml, there are none (in PyPi) for GDAL.

We recommend Windows users install GDAL from either
Christoph Gohlke's [Unofficial Windows Binaries for Python Extension Packages](http://www.lfd.uci.edu/~gohlke/pythonlibs)
(built against numpy 1.9) or the the [GIS Internals](http://www.gisinternals.com) MSVC 2008 installers
which are built against numpy 1.7.  Download the appropriate GDAL wheel/msi for your Python architecture
(either 32 or 64 bit) and install.

For ease of installing both the GDAL python bindings and the ECW/MrSID plugins, we have repackaged the above
 wheels/installers into pip installable wheels complete with the plugins.

If you have numpy 1.7 installed (i.e an ArcGIS 10.1 or 10.2 python installation):

    pip install --user -i https://pypi.anaconda.org/luke/channel/np17/simple gdal

If you have numpy 1.9 installed:

    pip install --user -i https://pypi.anaconda.org/luke/channel/np19/simple gdal

If you don't have numpy installed, use either method, metageta will still run, but if you use GDAL for anything else,
you won't be able to import the ```gdal_array``` module or call the ```ReadAsArray``` functions.`

## Usage
To use MetaGETA as provided, the first step is to crawl the filesystem to locate imagery and extract metadata to a
spreadsheet. Writing to a spreadsheet allows for quality control, such as removal of records, checking for duplicates, bulk updates, etc. It also allows the addition of extra metadata fields such as contacts, use and access constraints etc. Information on additional metadata fields can be found [here](https://htmlpreview.github.io/?https://github.com/lpinner/metageta/blob/master/doc/files/metageta.transforms-module.html).

If you don't like spreadsheets, it's quite simple to roll your own script that writes straight to XML, database,
etc... Check out the [API documentation](https://htmlpreview.github.io/?https://github.com/lpinner/metageta/blob/master/doc/index.html) for more info.

You can run the crawler and transform applications by simply double clicking or calling the runcrawler/runtransform
executables (on Windows, you may need to add your install path to your PATH environment variable).

    usage: runcrawler [arguments]
    Run the metadata crawler. If no arguments are passed, a dialog box pops up.
    Options:
        -h, --help            show this help message and exit
        -d dir                The directory to crawl
        -r, --recurse         Search directory recursively
        -a, --archive         Search compressed archives (tar/zip)?
        -m media              CD/DVD ID
        -x xlsx               Output metadata spreadsheet
        -u, --update          Update existing crawl results
        -o, --overviews       Generate overview images
        -e excludes, --exclude=excludes
                              File/directory exclusion pattern (Glob style matching of path/directory basenames)
        --keep-alive Reopen the dialog box after the crawl
        --debug               Turn debug output on

The information extracted can then be transformed into XML. Currently only the ANZLIC Profile (ISO 19139)
metadata schema is implemented for XML transformation, however more stylesheets can be added (PR welcome).

    Usage: runtransform [arguments]
    Transform metadata to XML. If no arguments are passed, a dialog box pops up.
    Options:
	    -h, --help show this help message and exit
	    -x xlsx Excel spreadsheet to read metadata from
	    -t xsl XSL transform {.xsl|"ANZLIC Profile"}
	    -m Create Metadata Exchange Format (MEF) file
	    --debug Turn debug output on

The metadata transform relies on a (per user) xml config file ([defaults](https://github.com/lpinner/metageta/blob/master/metageta/config/config.xml))
which can be edited using the ```metagetaconfig``` command.


text:
## Models and Views

### Design view

The image below shows a high-level view of the system's components.

![alt text](./design-view.png "Design View")

### Data model of a (not open source) smart lighting web application

_Image showing the datamodel for the owners and management application_
![alt text](./data-model-web-application.png "Data Model Web Application")

Data model explanation:

| **Table** | **Description** |
| --- | --- |
| devices | Devices tabel |
| organizations | Organization table with userinfo. |
| lightmeasurementdevices | Light measurement table for linking to devices and conversion to transitions (via sms\_type and sms\_index) of incoming light measurement texts. |
| groups | Device groups. Device can exist only in 0 or 1 group. |
| Lighting schedule | Available lighting schedules linked to device (after upload of schedule). |
| Tariff schedule | Available tariff schedules linked to device (after upload of schedule). |
| Keyvalue settings | Key/value pairing to store dynamic configuration. Organisations have their own configuration. |
| Burninghour reports | Monthly Burninghour reports |
| Burninghour report devices | Device informatie burninghour report |
| Burninghour report data | Data related to a device in burninghour report. |

### Logical view

The logical view is a high-level overview of the system. The image below displays the main components and interfaces between these components.

 ![alt text](./logical-view.png "Logical View")

### Technology selection

Open LDAP is not applied. A database solution was chosen instead of Directory services for authorisation.


text:
***

### Skill Details

* **Invocation Name:** go proverbs
* **Category:** null
* **ID:** amzn1.ask.skill.0c2dcddc-99ad-4ca8-8f76-8139d25208c9
* **ASIN:** B01MZZH05P
* **Author:** Rungo, LLC
* **Release Date:** November 30, 2016 @ 07:35:26
* **In-App Purchasing:** No


text:
# Privacy - Marketcord (Last Updated June 1st, 2021)

At Marketcord, we value the privacy of our customers more than anything else. This document contains all legal info bearing the privacy of our customers. For any suggestions, comments, or concerns, please contact mdev01#0001 or yash#1234 on Discord.
This Privacy Policy is effective as of June 1st, 2021.

**Section 1 - General Overview**\
This section will contain a general overview of everything stated in this legal document.
All data that Marketcord uses is not shared with our partners, sponsors, or other third party services. If you would like to request all of the data that Marketcord collects from you, please open a ticket in our [Discord](https://discord.gg/tQMg8JZMxc) channel.
As trust is something that we value the most at Marketcord, we strive to secure all of your data. No personal data is shared within Marketcord.

**Section 2 - What We Collect**\
As we use Discord's OAuth service to register accounts, the only information we collect is your Discord username/ID and your server ID. We also log all content that you send or receive in our services. We also log account balances and specific transactions. If we think that you may pose a threat to our service, we may collect some of your other info for further investigation.

**Section 3 - Why We Collect Data**\
The data that we collect is very important to us as it helps us deliver new services and push out updates that would improve the service and leave a better experience for our customer. We also collect data to measure performance and analytics. We love to see Marketcord grow, and by using analytics we can display that data. We use information like ID's to contact you directly and verify your status. We also use information to protect our clients. Security is extremely important for us and these analytics can help us develop more secure services. If you would like to request your data or
delete it, please open a ticket in our Discord server.

**Section 4 - What Data We Share**\
We don't share any data at all. 100% of the data that we collect is protected and never shared to our partners, sponsors, or other third party services. If we need to share data, we will directly contact you asking for consent to share it unless it is needed for legal purposes. Remember that Marketcord will never ask for your password.

**Section 5 - How Your Information Is Secure**\
At Marketcord, we work hard every day to protect your data as well as come up with new ideas to protect data. Some ways that we protect data include:
 -Secure data encryption when in transit
 -Range of security features
 -We review our storage and service daily to prevent unauthorized access to our system
 -We restrict access to information to Management roles
You can request a copy of your information or request to delete it at any time. No data is retained after being deleted unless the user creates a new account.

**Section 6 - About This Policy**\
This Privacy Policy applies to all of the services offered by Marketcord and its affiliates. We will change this policy from time to time when it needs to be updated. We will always state the date for when the policy is effective.

**Author:** Yash

repository: LeViski/legal

repo_name: LeViski/legal


text:
{% multimethod %}
{% endmultimethod %}

# Toll Free Porting Validation {#top}

# Overview
  * [API Overview](#api-overview)
    * [Create Order](#create-toll-free-validation-order)
    * [Query Orders](#query-toll-free-validation-orders)
    * [Query Order](#query-toll-free-validation-order)
    * [Update Order](#update-toll-free-validation-order)
  * [How to Use](#how-to-use-the-endpoint-in-conjunction-with-porting)

In order to successfully port toll free telephone numbers using Bandwidth’s /portins API, the list of toll free telephone numbers to port must consist of portable numbers that all come from the same controlling RespOrg. If you submit non-portable toll free numbers, or a mix of numbers from different RespOrgs, the port-in request is rejected, wasting everyone’s time and money.

To help eliminate this waste, Bandwidth has implemented an API that allows toll free porting API customers to query a list of toll free telephone numbers for status and RespOrg breakdown.  This will help toll free porting customers avoid submitting port-in orders that might otherwise be rejected.

# API Overview
The new API Operations are as follows:

| Method                           | Endpoint                                                     |
|:---------------------------------|:-------------------------------------------------------------|
| POST   | `/accounts/<accountId>/tollFreePortingValidations`           |
| GET     | `/accounts/<accountId>/tollFreePortingValidations`           |
| GET     | `/accounts/<accountId>/tollFreePortingValidations/<orderId>` |
| PATCH | `/accounts/<accountId>/tollFreePortingValidations/<orderId>` |

{% extendmethod %}
## Create Toll Free Validation Order
This endpoint allows users to submit a list of toll free numbers to determine if they are portable, and to determine how many separate port-ins will be needed. It creates a /tollFreePortingValidations order and assigns a unique order-id to that order, which is then returned in the HTTP response.

{% common %}
### Request
```http
POST https://dashboard.bandwidth.com/api/accounts/{{accountId}}/tollFreePortingValidations HTTP/1.1
Content-Type: application/xml; charset=utf-8
Authorization: Basic dXNlcm5hbWU6cGFzc3dvcmQ=

<TollFreePortingValidation>
    <!-- The CustomerOrderId is an optional string that may be associated with the order.  -->
    <!-- It will be included in all responses and notifications related to the order, and may be used to correlate with an order in a customer system. -->
    <CustomerOrderId>MyOptionalOrderId</CustomerOrderId>
    <!-- The TollFreeNumberList is a list of toll free telephone numbers for which you want information about the status and RespOrg from SOMOS. -->
    <!-- The list may consist of up to 5,000 toll free telephone numbers in one order.  The more numbers in the order, the longer it will take the order to complete. -->
    <TollFreeNumberList>
        <TollFreeNumber>8442948899</TollFreeNumber>
        <TollFreeNumber>8774024485</TollFreeNumber>
    </TollFreeNumberList>
</TollFreePortingValidation>
```

### Response
```xml
<TollFreePortingValidationResponse>
    <TollFreePortingValidation>
        <CustomerOrderId>MyOptionalOrderId</CustomerOrderId>
        <ProcessingStatus>PROCESSING</ProcessingStatus>
        <AccountId>9900572</AccountId>
        <CreatedByUser>jgilmore</CreatedByUser>
        <OrderCreateDate>2020-08-20T14:51:58.695Z</OrderCreateDate>
        <OrderId>e2b029cf-1cfa-4285-a875-80e8fd951208</OrderId>
        <TollFreeNumberList>
            <TollFreeNumber>8442948899</TollFreeNumber>
            <TollFreeNumber>8774024485</TollFreeNumber>
        </TollFreeNumberList>
    </TollFreePortingValidation>
</TollFreePortingValidationResponse>
```

{% endextendmethod %}

{% extendmethod %}
## Query Toll Free Validation Orders
This endpoint allows users to fetch a list of all /tollFreePortingValidations orders that exist for the specified accountId. This is useful if you lose track of an order-id.

**Note that /tollFreePortingValidations orders are automatically removed after a few days because the data can become stale as toll free numbers are reserved, freed, etc.**

{% common %}
### Request
```http
GET https://dashboard.bandwidth.com/api/accounts/{{accountId}}/tollFreePortingValidations HTTP/1.1
Authorization: Basic dXNlcm5hbWU6cGFzc3dvcmQ=
```

### Response
```xml
<TollFreePortingValidationResponses>
    <!-- A sample order that is still processing -->
    <TollFreePortingValidationResponse>
        <TollFreePortingValidation>
            <CustomerOrderId>MyOptionalOrderId</CustomerOrderId>
            <ProcessingStatus>PROCESSING</ProcessingStatus>
            <AccountId>9900572</AccountId>
            <CreatedByUser>jgilmore</CreatedByUser>
            <OrderCreateDate>2020-08-20T14:51:58.695Z</OrderCreateDate>
            <OrderId>e2b029cf-1cfa-4285-a875-80e8fd951208</OrderId>
            <TollFreeNumberList>
                <TollFreeNumber>8442948899</TollFreeNumber>
                <TollFreeNumber>8774024485</TollFreeNumber>
            </TollFreeNumberList>
        </TollFreePortingValidation>
    </TollFreePortingValidationResponse>
    <!-- A sample order that completed -->
    <TollFreePortingValidationResponse>
        <TollFreePortingValidation>
            <CustomerOrderId>MyOptionalOrderId</CustomerOrderId>
            <ProcessingStatus>COMPLETE</ProcessingStatus>
            <AccountId>9900572</AccountId>
            <CreatedByUser>jgilmore</CreatedByUser>
            <OrderCreateDate>2020-08-20T14:51:58.695Z</OrderCreateDate>
            <OrderId>e2b029cf-1cfa-4285-a875-80e8fd951208</OrderId>
            <TollFreeNumberList>
                <TollFreeNumber>8442948899</TollFreeNumber>
                <TollFreeNumber>8774024485</TollFreeNumber>
            </TollFreeNumberList>
            <Breakdown>
                <PortableTollFreeNumberList>
                    <RespOrgList>
                        <RespOrg>
                            <Id>RespOrg1</Id>
                            <RespOrgException>true</RespOrgException>
                            <TollFreeNumberList>
                                <TollFreeNumber>8442948899</TollFreeNumber>
                                <TollFreeNumber>8774024485</TollFreeNumber>
                            </TollFreeNumberList>
                        </RespOrg>
                    </RespOrgList>
                </PortableTollFreeNumberList>
            </Breakdown>
        </TollFreePortingValidation>
    </TollFreePortingValidationResponse>
```

{% endextendmethod %}

{% extendmethod %}
## Query Toll Free Validation Order
This endpoint allows users to fetch the status of a specified /tollFreePortingValidations order. Possible status values are SUBMITTED, PROCESSING, COMPLETE, FAILED, or CANCELLED. See below for more information on what each status represents.

| Status     | Definition |
|:-----------|:-----------|
| SUBMITTED  | The request has been submitted but has not yet been acknowledged. |
| PROCESSING | The request is processing but the order is not yet complete. |
| COMPLETE   | The order is complete.  All toll free numbers in the request are portable, but may belong to more than one RespOrg. |
| FAILED     | One or more toll free numbers included in the request is not portable.  The breakdown shows which toll free numbers are not portable and the reason why. |
| CANCELLED  | The order was cancelled by the user (using the PATCH operation) prior to our receiving a result from the vendor. |

{% common %}
### Request
```http
GET https://dashboard.bandwidth.com/api/accounts/{{accountId}}/tollFreePortingValidations/{orderId} HTTP/1.1
Authorization: Basic dXNlcm5hbWU6cGFzc3dvcmQ=
```

### Response
```xml
<TollFreePortingValidationResponse>
    <TollFreePortingValidation>
        <CustomerOrderId>MyOptionalOrderId</CustomerOrderId>
        <ProcessingStatus>PROCESSING</ProcessingStatus>
        <AccountId>9900572</AccountId>
        <CreatedByUser>jgilmore</CreatedByUser>
        <OrderCreateDate>2020-08-20T14:51:58.695Z</OrderCreateDate>
        <OrderId>e2b029cf-1cfa-4285-a875-80e8fd951208</OrderId>
        <TollFreeNumberList>
            <TollFreeNumber>8442948899</TollFreeNumber>
            <TollFreeNumber>8774024485</TollFreeNumber>
        </TollFreeNumberList>
    </TollFreePortingValidation>
</TollFreePortingValidationResponse>
```

{% endextendmethod %}

{% extendmethod %}
## Update Toll Free Validation Order
This endpoint allows users to cancel a /tollFreePortingValidations order if you they longer wish to wait for the results, or if they realize that changes are needed in the list of toll free numbers in the request.

{% common %}
### Request
```http
PATCH https://dashboard.bandwidth.com/api/accounts/{{accountId}}/tollFreePortingValidations HTTP/1.1
Content-Type: application/xml; charset=utf-8
Authorization: Basic dXNlcm5hbWU6cGFzc3dvcmQ=

<TollFreePortingValidation>
    <ProcessingStatus>CANCELLED</ProcessingStatus>
</TollFreePortingValidation>
```

### Response
```xml
<TollFreePortingValidationResponse>
    <TollFreePortingValidation>
        <CustomerOrderId>MyOptionalOrderId</CustomerOrderId>
        <ProcessingStatus>CANCELLED</ProcessingStatus>
        <AccountId>9900572</AccountId>
        <CreatedByUser>jgilmore</CreatedByUser>
        <OrderCreateDate>2020-08-20T14:51:58.695Z</OrderCreateDate>
        <OrderId>e2b029cf-1cfa-4285-a875-80e8fd951208</OrderId>
        <TollFreeNumberList>
            <TollFreeNumber>8442948899</TollFreeNumber>
            <TollFreeNumber>8774024485</TollFreeNumber>
        </TollFreeNumberList>
    </TollFreePortingValidation>
</TollFreePortingValidationResponse>
```

{% endextendmethod %}

# How to use the Endpoint in Conjunction with Porting
Prior to submitting your `/portins` request, simply POST a `/tollFreePortingValidations` request with the list of toll free numbers you wish to port.  Bandwidth will determine the current status and RespOrg ownership of each toll free number. A report is generated, breaking down the list of toll free telephone numbers into the following categories:
  * **Spare Numbers** - these are toll free telephone numbers that are not currently associated with a particular RespOrg. They are not available for porting, but can be ordered from the industry.  Bandwidth can help you reserve spare toll free numbers using the same process you would use for toll free vanity number requests.
  * **Unavailable Numbers** - these are toll free numbers that are not available for use.  Typically this includes toll free numbers that are reserved for future expansion.
  * **Denied Numbers** - these toll free numbers are not portable due to a problem like, for example, the NXX has not yet been opened for service.
  * **Numbers Belonging to a RespOrg Ending in 99** - it is industry convention that toll free numbers cannot be ported away from a RespOrg ID that ends in 99.
  * **Portable Numbers** - these are toll free numbers that are currently assigned to a RespOrg and are candidates for porting.  Numbers in this category are broken down further by the RespOrg that is currently responsible for the toll free number.

This allows you to separate your numbers by RespOrg without having to worry about the actual RespOrg ID.

For requests with only a few toll free numbers, these requests are generally serviced within 5 to 10 seconds.  But if you submit a request with several hundred toll free numbers, it can take 3 to 5 minutes to get the results. **Please note that these times are not guaranteed and can vary depending on load.**

If you wish to be notified of /tollFreePortingValidations order status changes, you may subscribe to notification via web hook, or via email.  For information on subscribing for order notifications, please see [our documentation regarding subscriptions](./account/subscriptions/about.md).

For detailed information on the /tollFreePortingValidations endpoints and supported operations, please refer to Bandwidth’s [Numbers API reference](./apiReference.md).


text:
# Python Data Checker 💻

* Use python 3.7.X or above

## Notes 🗒

* Inputs are validated withing a range
* At least 1 argument is needed
* min, max and expected values must be provided
* No extra libraries needed

Clone and change it as you wish 🎨.


text:
# LocalFilters.jl

[![License](http://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat)](LICENSE.md)
[![Build Status](https://travis-ci.org/emmt/LocalFilters.jl.svg?branch=master)](https://travis-ci.org/emmt/LocalFilters.jl)
[![Build Status](https://ci.appveyor.com/api/projects/status/github/emmt/LocalFilters.jl?branch=master)](https://ci.appveyor.com/project/emmt/LocalFilters-jl/branch/master)
[![Coverage Status](https://coveralls.io/repos/emmt/LocalFilters.jl/badge.svg?branch=master&service=github)](https://coveralls.io/github/emmt/LocalFilters.jl?branch=master)
[![codecov.io](http://codecov.io/github/emmt/LocalFilters.jl/coverage.svg?branch=master)](http://codecov.io/github/emmt/LocalFilters.jl?branch=master)

This package implements multi-dimensional local filters for
[Julia](http://julialang.org/) (convolution, mathematical morphology, etc.).
Local filters are defined by specific operations combining each value of a
source array with the values in a local neighborhood which may have any size,
shape and dimensionality.  Predefined local filters are provided as well as
means to simply implement custom filters.

This document is structured as follows:

* [Summary](#summary) provides a quick introduction.

* [Implementation](#implementation) explains how to implement you own filter.

* [Neighborhoods](#neighborhoods) describes the concept of neighborhoods.

* [Installation](#installation) to install the package.

Note that this is a first implementation to define the API.  It is is
reasonably fast (see [benchmarks.jl](src/benchmarks.jl)) but separable kernels
can be made faster.

Packages with overlapping functionalities:

* [ImageFiltering](https://github.com/JuliaImages/ImageFiltering.jl) for local
  filters on multidimensional arrays (not just *images*), also implement
  various boundary conditions;

* [ImageMorphology](https://github.com/JuliaImages/ImageMorphology.jl) for fast
  morphological operations with separable structuring elements;

## Summary

**LocalFilters** implements local filtering operations which combine the values
of an array in a neighborhood of each elements of the array (and possibly the
values of a kernel associated with the neighborhood).  The neighborhood is
defined relatively to a given position by an instance of a type derived from
`Neighborhood`.  For
[mathematical morphology](https://en.wikipedia.org/wiki/Mathematical_morphology)
operations, a neighborhood is called a *structuring element*.

Denoting `A` the source array and `B` the neighborhood or the kernel (by
default `B` is a centered box of size 3 along every dimension), the available
filters are:

* `erode(A, B=3)` performs an erosion (local minimum) of `A` by `B`;

* `dilate(A, B=3)` performs a dilation (local maximum) of `A` by `B`;

* `localextrema(A, B=3)` yields the erosion and the dilation of `A` by `B`;

* `opening(A, B=3)` performs an erosion followed by a dilation;

* `closing(A, B=3)` performs a dilation followed by an erosion;

* `top_hat(A, B=3 [, S])` performs a summit detection (an optional third
  argument `S` may be supplied to pre-smooth `A` by `S`);

* `bottom_hat(A, B=3 [, S])` performs a valley detection (an optional third
  argument `S` may be supplied to pre-smooth `A` by `S`);

* `localmean(A, B=3)` performs a local averaging;

* `convolve(A, B=3)` performs a convolution by the kernel `B` or by the support
  of `B` is `eltype(B)` is `Bool`;

* `bilateralfilter(A, Fr, Gs)` performs a bilateral filtering of array `A` with
  `Fr` the range kernel for smoothing differences in intensities and `Gs` the
  spatial kernel for smoothing differences in coordinates (see:
  https://en.wikipedia.org/wiki/Bilateral_filter).

and many more to come...

## Implementation

The pseudo-code for a local filtering operation `C = filter(A, B)` writes:

```julia
for i ∈ Sup(A)
    v = initial(A[i])
    for j ∈ Sup(B) and such that i-j ∈ Sup(A)
        v = update(v, A[i-j], B[j])
    end
    store(C, i, v)
end
```

where `A` is the source of the operation, `B` is the neighborhood, `C` is the
result of the operation.  Here `Sup(A)` denotes the support of `A` (that is the
set of indices in `A`).  The methods `initial`, `update` and `store` are
specific to the considered operation.  To execute the filter, call the
`localfilter!` method as:

```julia
localfilter!(dst, A, B, initial, update, store)
```

`localfilter!` applies the local filter defined by the neighborhood `B` and
methods `initial`, `update` and `store` to the source array `A` and stores the
reseult in the destination `dst` which is then returned.

For instance, to compute a local maximum (*i.e.* a **dilation** in mathematical
morphology terms):

```julia
initial(a) = typemin(T)
update(v,a,b) = (b && v < a ? a : v)
store(c,i,v) = c[i] = v
```

with `T` the type of the elements of `A`.  Of course, anonymous functions can
be exploited to implement this filter in a single call:

```julia
localfilter!(dst, A, B,
             (a)     -> typemin(T),           # initial method
             (v,a,b) -> (b && v < a ? a : v), # update method
             (c,i,v) -> c[i] = v)             # store method
```

Below is another example of the methods needed to implement a local average:

```julia
initial(a) = (0, zero(T))
update(v,a,b) = v[1] + 1, v[2] + (b ? a : zero(T))
store(c,i,v) = c[i] = v[2]/v[1]
```

The same mechanism can be used to implement other operations such as
convolution, median filtering, *etc.* via the `localfilter!` driver.

## Neighborhoods

`Neighborhood` (a.k.a. *structuring element* for the fans of mathematical
morphology) is a central concept in `LocalFilters`.  The neighborhood defines
which values are involved in a local operation for each component of the source
array.  Neighborhoods are assumed to be shift invariant but may have any
support shape and may have embedded weights (*e.g.*, to implement *local
convolution*).

### Types of neighborhoods

From the user point of view, there are three kinds of neighborhoods:

* **Rectangular boxes** are rectangular neighborhoods whose edges are aligned
  with the axes of array indices and which may be centered or have arbitrary
  offsets along the dimensions.  These neighborhoods are represented by
  instances of `LocalFilters.RectangularBox`.

* **Arbitrarily shaped neighborhoods** are neighborhoods with arbitrary shape
  and offset.  These neighborhoods are represented by instances of
  `LocalFilters.Kernel` with boolean element type.  These neighborhoods are
  constructed from an array of booleans and an optional starting index.

* **Kernels** are neighborhoods whose elements are weights and which be may
  have arbitrary offset.  These neighborhoods are represented by instances of
  `LocalFilters.Kernel` with numerical element type.  These neighborhoods are
  constructed from an array of weights and an optional starting index.

### Syntax for neighborhoods

* The *default neighborhood* is a centered rectangular box of width 3 in each
  of its dimensions.

* A *scalar* integer `w` yields a centered rectangular box of size `w` along
  all dimensions.  `w` must be at least equal to 1 and the geometrical center
  of the box is defined according to the conventions in `fftshift`.

* A *tuple* `t` of integers yields a centered rectangular box whose size is
  `t[i]` along the `i`-th dimension.  All values of `t` must be larger or equal
  to 1.  Tip: Remember that you can use `v...` to convert a *vector* `v` into a
  tuple.

* An *array* `A` yields a `LocalFilters.Kernel` whose coefficients are the
  values of `A` and whose neighborhood is the centered bounding-box of `A`.

* A *Cartesian range* `R` (an instance of `CartesianIndices` or of
  `CartesianRange`) yields a `LocalFilters.RectangularBox` which is a
  rectangular neighborhood whose support contains all relative positions within
  `first(R)` and `last(R)`.

* A rectangular box neighborhood created by calling
  `LocalFilters.RectangularBox` as:

  ```julia
  LocalFilters.RectangularBox(R)
  LocalFilters.RectangularBox(I1, I2)
  LocalFilters.RectangularBox(dims, offs)
  LocalFilters.RectangularBox(inds)
  ```

  where `R` is an instance of`CartesianIndices` (or of `CartesianRange` for old
  Julia version), `I1` and `I2` are two `CartesianIndex` specifying the first
  and last relative position within the neighborhood, `dims` and `offs` are
  tuples of integers specifying the dimensions of the neighborhood and its
  offsets, `inds` are unit ranges.

  Assuming `dim` is an integer, then:

  ```julia
  LocalFilters.RectangularBox{N}(dim)
  ```

  yields an `N`-dimensional rectangular box of size `dim` along all dimensions
  and centered at the geometrical center of the box (with the same conventions
  as `fftshift`).

  Similarly, assuming `i1` and `i2` are integers, then:

  ```julia
  LocalFilters.RectangularBox{N}(i1:i2)
  ```

  yields an `N`-dimensional rectangular box with index range `i1:i2` along all
  dimensions.

### Methods on a neighborhood

The following methods make sense on a neighborhood `B`:

```julia
eltype(B) -> element type of B
ndims(B)  -> number of dimensions of B
length(B) -> number of elements in the bounding-box of B
size(B)   -> size of the bounding-box of B along all dimensions
size(B,d) -> size of the bounding-box of B along d-th dimension
first(B)  -> CartesianIndex of first position in the bounding-box
             of B relative to its anchor
last(B)   -> CartesianIndex of last position in the bounding-box
             of B relative to its anchor
B[i]      -> yields the kernel value of B at index i
```

Note that the index `i` in `B[i]` is assumed to be between `first(B)` and
`last(B)`, for efficiency reasons this is not checked.  The type returned by
`eltype(B)` is `Bool` for a neighborhood which is just defined by its support
(*e.g.* a `LocalFilters.CenteredBox` or a `LocalFilters.RectangularBox`), the
element type of its kernel otherwise.

```julia
CartesianRange(B)
```

yields the Cartesian range of relative positions of the bounding-box of
neighborhood `B`.

If the argument `B` which defines a neighborhood (see previous section) is not
an instance of a type derived from `LocalFilters.Neighborhood`, it may be
explicitly converted by:

```julia
convert(LocalFilters.Neighborhood{N}, B)
```

with `N` the number of dimensions of the target array.

## Installation

To install the last official version:

```julia
using Pkg
Pkg.add("LocalFilters")
```

To use the last development version:

```julia
using Pkg
Pkg.clone("https://github.com/emmt/LocalFilters.jl.git")
```

The `LocalFilters` package is pure Julia code and there is nothing to build.


text:
---
layout: post
title: "Feeling stuck? Ask the duck!"
date:   2021-04-04 10:30:00 +0300
thumbnail-img: /assets/img/batman-duck.jpeg
cover-img: /assets/img/giant-duck.jpg
categories:
tags: [python, mock, rubber-duck]
---

As a developer (or not) you may have heard the expression above.
It's very common to be in a state where you feel stuck in a problem
and you need to ask somebody for help.

And as soon as you start expressing your problem, new ideas start appearing
out of the blue!

Well this is where the duck is coming handy! Instead of finding someone else,
you start talking to the duck and (maybe) ideas are start flowing again!

And a rubber duck can be very cute and handy, but today's post is all about
an interactive terminal duck!

Before starting working with this, I bumped into two repositories that kinda
were doing what I wanted to... One was a
[rubber ducky chatbot for slack](https://github.com/s-wigg/Rubber-Ducky-Chatbot)
in python and the other was a
[rubber duck app for terminal](https://github.com/kaicataldo/rubberducky) in javascript.

Yet another one rubber duck app? For start I need to practice my dev
skills in Python. And secondly, I love the idea of having a chatbot
rubber ducky for slack but that's not feasible now.

So, I thought, why not combining the two of them?

And there it was born my rubber ducky for terminal! Based on the
functionallity of the chatbot ducky I have changed a couple of
things that weren't working anymore and I worked in order to
figure out what the original creator had in mind and
make it my own and produce a great terminal app too.

You can find more about it [here](https://github.com/kgiann78/rubberducky)


text:
To define attributes for input (e.g. `style` or `placeholder`) you can define them
on the original element with `e-*` prefix (e.g. `e-style` or `e-placeholder`).
To customize the classes on the form the input is in, add `e-formclass` with the classes to be added.
When input will appear these attributes will be transferred to it.

repository: ttonyh/angular-xeditable

repo_name: ttonyh/angular-xeditable


text:
---
title: C
weight: 1
toc: true
---

Two options are available for C developers, CZMQ or libzmq, the low-level zeromq library.

The recommended binding for C developers is CZMQ, which provides a high-level API for ØMQ, with additional classes such as pollers, thread management, and security helpers.

## CZMQ

Github

[https://github.com/zeromq/czmq](https://github.com/zeromq/czmq)

Docs

[http://czmq.zeromq.org/](http://czmq.zeromq.org/)

### Install

First [install libzmq]({{< relref "/docs/download" >}}).

#### Ubuntu/Debian/Mint

```bash
apt-get install libczmq-dev
```

#### Fedora

```bash
dnf install czmq-devel
```

#### OSX

```bash
brew install czmq
```

#### Windows

Using vcpkg

```batch
.\vcpkg.exe install czmq
```

this will build czmq as a 32-bit shared library.

```batch
.\vcpkg.exe install czmq:x64-windows-static
```

this will build czmq as a 64-bit static library.

To use the draft APIs, you may build czmq with draft feature:

```batch
.\vcpkg install czmq[draft]
```

### Example

```c
#include <czmq.h>
int main (void)
{
    zsock_t *push = zsock_new_push ("inproc://example");
    zsock_t *pull = zsock_new_pull ("inproc://example");
    zstr_send (push, "Hello, World");

    char *string = zstr_recv (pull);
    puts (string);
    zstr_free (&string);

    zsock_destroy (&pull);
    zsock_destroy (&push);
    return 0;
}
```

## libzmq

Github

[https://github.com/zeromq/libzmq](https://github.com/zeromq/libzmq)

Docs

[http://api.zeromq.org/](http://api.zeromq.org/)

### Install

Following the instructions on [download page]({{< relref "/docs/download" >}}).

### Example

Server:
```C
#include <zmq.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <assert.h>

int main (void)
{
    //  Socket to talk to clients
    void *context = zmq_ctx_new ();
    void *responder = zmq_socket (context, ZMQ_REP);
    int rc = zmq_bind (responder, "tcp://*:5555");
    assert (rc == 0);

    while (1) {
        char buffer [10];
        zmq_recv (responder, buffer, 10, 0);
        printf ("Received Hello\n");
        sleep (1);          //  Do some 'work'
        zmq_send (responder, "World", 5, 0);
    }
    return 0;
}
```

Client:

```C
#include <zmq.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>

int main (void)
{
    printf ("Connecting to hello world server…\n");
    void *context = zmq_ctx_new ();
    void *requester = zmq_socket (context, ZMQ_REQ);
    zmq_connect (requester, "tcp://localhost:5555");

    int request_nbr;
    for (request_nbr = 0; request_nbr != 10; request_nbr++) {
        char buffer [10];
        printf ("Sending Hello %d…\n", request_nbr);
        zmq_send (requester, "Hello", 5, 0);
        zmq_recv (requester, buffer, 10, 0);
        printf ("Received World %d\n", request_nbr);
    }
    zmq_close (requester);
    zmq_ctx_destroy (context);
    return 0;
}
```


text:
Datatables.AspNet

Formely known as DataTables.Mvc, this project startedwith small objectives around 2014, aiming to provide intermediate and experienced developers a tool to avoid the boring process of handling DataTables parameters.

More than a year later and after a full rewrite we are now proud to support Asp.net MVC, WebApi and Asp.Net Core (full .NET Core support).

Unit-testing is a priority to avoid breaking your app and every stable release should provide better and wider test cases.

Stable 2.0.0 version is here!

`2.0.0` stable release now ships with full support for DotNet Core 1.0.0, along with extensions, tests and all the fun we can get.
This is the first stable version for `DataTables.AspNet`. We dropped the full migration path because we made everything clean and simple and included some basic usage samples to guide you.

Standard NuGet packages

- [DataTables.AspNet.Mvc5](https://www.nuget.org/packages/DataTables.AspNet.Mvc5/) with support for Mvc5, registration and automatic binders

- [DataTables.AspNet.WebApi2](https://www.nuget.org/packages/DataTables.AspNet.WebApi2/) with support for WebApi2, registration and automatic binders

- [DataTables.AspNet.AspNetCore](https://www.nuget.org/packages/DataTables.AspNet.AspNetCore/) with support for AspNetCore, dependency injection and automatic binders

IMPORTANT: Deprecated (unlisted) package

- [DataTables.AspNet.AspNet5](https://www.nuget.org/packages/DataTables.AspNet.AspNet5/)

This package has been replaced by DataTables.AspNet.AspNetCore due to Microsoft renaming of the new platform.

Write your own code!

DataTables.AspNet ships with a core project called [DataTables.AspNet.Core](https://www.nuget.org/packages/DataTables.AspNet.Core/), which contains basic interfaces and core elements just the way DataTables needs.

Feel free to use it and implement your own classes, methods and extend DataTables.AspNet in your very own way.

Helpers and extensions

- [DataTables.AspNet.Extensions.AnsiSql](https://www.nuget.org/packages/DataTables.AspNet.Extensions.AnsiSql/) enables basic translation from sort and filter into ANSI-SQL `WHERE` and `ORDER BY`

- [DataTables.AspNet.Extensions.DapperExtensions](https://www.nuget.org/packages/DataTables.AspNet.Extensions.DapperExtensions/) transforms filters into `IPredicate` and sort into `ISort`

Those are still alpha1 releases but with nuget packages available. There are no tests yet, they are in a very initial phase and might change a bit in the near future.
After they become stable I'll accept pull requests for other extensions (eg: NHibernate, EntityFramework, etc). For now, keep in mind that these two are supposed to set the basic extension standard for DataTables.AspNet.Extensions.

Samples

Samples are provided on the `samples` folder.

There is no wiki yet. I will start writing a very gorgeous wiki, just don't know when. Tons of work and no time. Sorry.
I am open to contributors :)

Eager for some new code?

If you are, check out [dev](https://github.com/Avaruz/datatables.aspnet/tree/dev) branch. It has the latest code for DataTables.AspNet, including samples and more.

For every release (even unstable ones) there should be a nuget package.

Stable code?

For production code, I do recommend the `master` branch. It holds the stable version. Every stable version has a stable Nuget release.

Still legacy?

Drop it!

2.0.0 (stable) is faster, better coded and fully tested. DataTables.Mvc is now completely discontinued.

Known issues

- There are some issues while trying to run all tests simultaneously. I'll try to fix that by including some test ordering.
- Extension methods do not have tests yet and should not be used on production code.

branch_name: refs/heads/dev

gha_language: C#


text:
# BlazingSQL 0.16.0 (October 22, 2020)

## Improvements
- #997 Add capacity to set the transport memory
- #1040 Update conda recipe, remove cxx11 abi from cmake
- #977 Just one initialize() function at beginning and add logs related to allocation stuff
- #1046 Make possible to read the system environment variables to set up BlazingContext
- #998 Update TPCH queries, become implicit joins into implicit joins to avoid random values.
- #1055 Removing cudf source code dependency as some cudf utilities headers were exposed
- #1065 Remove thrift from build prodcess as its no longer used
- #1067 Upload conda packages to both rapidsai and blazingsql conda channels

## Bug Fixes
- #918 Activate validation for GPU_CI tests results.
- #975 Fixed issue due to cudf orc api change
- #1017 Fixed issue parsing fixed with string literals
- #1019 Fix hive string col
- #1021 removed an rmm include
- #1020 Fixed build issues with latest rmm 0.16 and columnBasisTest due to deprecated drop_column() function
- #1029 Fix metadata mistmatch due to parsedMetadata
- #1016 Removed workaround for parquet read schema
- #1022 Fix pinned buffer pool
- #1028 Match dtypes after create_table with multiple files
- #1030 Avoid read _metadata files
- #1039 Fixed issues with parsers, in particular ORC parser was misbehaving
- #1038 Fixed issue with logging dirs in distributed envs
- #1048 Pinned google cloud version to 1.16
- #1052 Partial revert of some changes on parquet rowgroups flow with local_files=True
- #1054 Can set manually BLAZING_CHACHE_DIRECTORY
- #1053 Fixed issue when loading paths with wildcards
- #1057 Fixed issue with concat all in concatenating cache
- #1007 Fix arrow and spdlog compilation issues
- #1068 Just adds a docs important links and avoid the message about filesystem authority not found
- #1073 Fixed parseSchemaPython can throw exceptions
- #1074: Remove lock inside grow() method from PinnedBufferProvider
- #1071 Fix crash when loading an empty folder
- #1085 Fixed intra-query memory leak in joins. Fixed by clearing array caches after PartwiseJoin is done
- #1096 Backport from branch-0.17 with these PRs: #1094, #1086, #1093 and #1091
- #1099 Fixed issue with config_options

# BlazingSQL 0.15.0 (August 31, 2020)

## New Features
- #835 Added a memory monitor for better memory management and added pull ordered from cache
- #889 Added Sphinx based code architecture documentation
- #968 Support PowerPC architecture

## Improvements
- #777 Update Calcite to the most recent version 1.23
- #786 Added check for concat String overflow
- #815 Implemented Unordered pull from cache to help performance
- #822 remove "from_cudf" code and cudf test utilities from engine code
- #824 Added a test on Calcite to compare the logical plans when the ruleset is updated
- #802 Support for timestampadd and constant expressions evaluation by Calcite
- #849 Added check for CUDF_HOME to allow build to use an existing prebuilt cudf source tree
- #829 Python/Cython check code style
- #826 Support cross join
- #866 Added nogil statements for pure C functions in Cython
- #784 Updated set of TPCH queries on the E2E tests
- #877 round robing dask workers on single gpu queries
- #880 reraising query errors in context.py
- #883 add rand() and running unary operations on literals
- #894 added exhale to generate doxygen for sphinx docs
- #887 concatenating cache improvement and replacing PartwiseJoin::load_set with a concatenating cache
- #885 Added initial set of unit tests for `WaitingQueue` and nullptr checks around spdlog calls
- #904 Added doxygen comments to CacheMachine.h
- #901 Added more documentation about memory management
- #910 updated readme
- #915 Adding max kernel num threads pool
- #921 Make AWS and GCS optional
- #925 Replace random_generator with cudf::sample
- #900 Added doxygen comments to some kernels and the batch processing
- #936 Adding extern C for include files
- #941 Logging level (flush_on) can be configurable
- #947 Use default client and network interface from Dask
- #945 Added new separate thresh for concat cache
- #939 Add unit test for Project kernel
- #949 Implemented using threadpool for outgoing messages
- #961 Add list_tables() and describe_table() functions
- #967 Add bc.get_free_memory() function

## Bug Fixes
- #774 fixed build issues with latest cudf 0.15 including updating from_cudf
- #781 Fixed issue with Hive partitions when doing SELECT *
- #754 Normalize columns before distribution in JoinPartitionKernel
- #782 fixed issue with hive partitions base folder
- #791 Fixes issues due to changes in rmm and fixes allocator issues
- #770 Fix interops operators output types
- #798 Fix when the algebra plan was provided using one-line as logical plan
- #799 Fix uri values computacion in runQueryCaller
- #792 Remove orc temp files when cached on Disk
- #814 Fix when checking only Limit and Scan Kernels
- #816 Loading one file at a time (LimitKernel and ScanKernel)
- #832 updated calcite test reference
- #834 Fixed small issue with hive and cudf_type_int_to_np_types
- #839 Fixes literal cast
- #838 Fixed issue with start and length of substring being different types
- #823 Fixed issue on logical plans when there is an EXISTS clause
- #845 Fixed issue with casting string to string
- #850 Fixed issue with getTableScanInfoCaller
- #851 Fix row_groups issue in ParquetParser.cpp
- #847 Fixed issue with some constant expressions not evaluated by calcite
- #875 Recovered some old unit tests and deleted obsolete unit tests
- #879 Fixed issue with log directory creation in a distributed environment
- #890 Fixed issue where we were including testing hpp in our code
- #891 Fixed issue caused by replacing join load_set with concatenating cache
- #902 Fixed optimization regression on the select count(*) case
- #909 Fixed issue caused by using now arrow_io_source
- #913 Fixed issues caused by cudf adding DECIMAL data type
- #916 Fix e2e string comparison
- #927 Fixed random segfault issue in parser
- #929 Update the GPUManager functions
- #942 Fix column names on sample function
- #950 Introducing config param for max orderby samples and fixing oversampling
- #952 Dummy PR
- #957 Fixed issues caused by changes to timespamp in cudf
- #962 Use new rmm API instead of get_device_resource() and set_device_resource() functions
- #965 Handle exceptions from pool_threads
- #963 Set log_level when using LOGGING_LEVEL param
- #973 Fix how we check the existence of the JAVA_HOME environment variable

# BlazingSQL 0.14.0 (June 9, 2020)

- #391 Added the ability to run count distinct queries in a distruted fashion
- #392 Remove the unnecessary messages on distributed mode
- #560 Fixed bug where parsing errors would lead to crash
- #565 made us have same behaviour as cudf for reading csv
- #612 Print product version: print(blazingsql.__version__) # shows the git hash
- #638 Refactores and fixes SortAndSample kernels
- #631 Implemented ability to send config_options to bc.sql function
- #621 Clean dead code
- #602 Implements cache flow control feature
- #625 Implement CAST to TINYINT and SMALLINT
- #632 Implement CHAR_LENGTH function
- #635 Handle behavior when the optimized plan contains a LogicalValues
- #653 Handle exceptions on python side
- #661 added hive support to parse_batch
- #662 updated from_cudf code and fixed other issue due to new cudf::list_view
- #674 Allow to define and use a specific AWS S3 region
- #677 added guava to pom.xml
- #679 Support modern compilers (>= g++-7.x)
- #649 Adding event logging
- #660 Changed how we handle the partitions of a dask.cudf.DataFrame
- #697 Update expression parser
- #659 Improve reading for: SELECT * FROM table LIMIT N
- #700 Support null column in projection
- #711 Migrate end to end tests into blazingsql repo
- #718 Changed all condition variable waits to wait_for
- #712 fixed how we handle empty tables for estimate for small table join
- #724 Removed unused BlazingThread creations
- #725 Added nullptr check to num_rows()
- #729 Fixed issue with num_rows() and wait_for
- #728 Add replace_calcite_regex function to the join condition
- #721 Handling multi-partition output
- #750 Each table scan now has its own data loader
- #740 Normalizing types for UNION ALL
- #744 Fix unit tests
- #743 Workaround for interops 64 index plan limitation
- #763 Implemented ability to set the folder for all log files
- #757 Ensure GPU portability (so we can run on any cloud instance with GPU)
- #753 Fix for host memory threshold parameter with Dask envs
- #801 Fix build with new cudf 0.15 and arrow 0.17.1
- #809 Fix conda build issues
- #828 Fix gpuci issues and improve tooling to debug gpuci related issues
- #867 Fix boost dependencie issues
- #785 Add script for Manual Testing Artifacts.
- #931 Add script for error messages validation.
- #932 Import pydrill and pyspark only when its generator or full mode.

repository: msadang/blazingsql

repo_name: msadang/blazingsql


text:
## Sorting and Filtering

### Sorting

> Example request sorting by a single condition:

```shell
curl -X GET https://api.resourcewatch.org/v1/dataset?sort=name
```

> Example request sorting by multiple conditions:

```shell
curl -X GET https://api.resourcewatch.org/v1/dataset?sort=name,description
```

> Example request sorting by multiple conditions, descending and ascending:

```shell
curl -X GET https://api.resourcewatch.org/v1/dataset?sort=-name,+description
```

As a rule of thumb, you can sort RW API resources using the `sort` query parameter. Usually, sorting can be performed using any field from the resource schema, so be sure to check each resource's model reference to find which fields can be used for sorting. Sorting by nested model fields is not generally supported, but may be implemented for particular resources. In some exceptional cases, you also have the possibility of sorting by fields that are not present in the resource model (e.g., when fetching datasets, you can sort by `user.name` and `user.role` to sort datasets by the name or role of the owner of the dataset) - be sure to check each resource's documentation to find out which additional sorting criteria you have available.

Multiple sorting criteria can be used, separating them by commas. You can also specify the sorting order by prepending the criteria with either `-` for descending order or `+` for ascending order. By default, ascending order is assumed.

Keep in mind that it’s up to each individual RW API service (dataset, widget, layer, etc) to define and implement the sorting mechanisms. Because of this, the examples above may not be true for all cases. Refer to the documentation of each resource and endpoint for more details on sorting.

#### Which services comply with these guidelines

The following endpoints adhere to the Sorting conventions defined above:

* [Get v2 areas endpoint](reference.html#getting-all-user-areas)
* [Get areas endpoint](reference.html#get-user-areas)
* [Get collections endpoint](reference.html#getting-collections-for-the-request-user)
* [Get dashboards endpoint](reference.html#getting-all-dashboards)
* [Get datasets endpoint](reference.html#getting-all-datasets)
* [Get layers endpoint](reference.html#getting-all-layers)
* [Get metadata endpoint](reference.html#getting-all-metadata)
* [Get widgets endpoint](reference.html#getting-all-widgets)

### Filtering

> Example request filtering using a single condition:

```shell
curl -X GET https://api.resourcewatch.org/v1/dataset?name=viirs
```

> Example request filtering using multiple conditions:

```shell
curl -X GET https://api.resourcewatch.org/v1/dataset?name=birds&provider=cartodb
```

> Example request filtering by an array field using the `,` OR multi-value separator:

```shell
curl -X GET https://api.resourcewatch.org/v1/dataset?application=rw,gfw
```

> Example request filtering by an array field using the `@` AND multi-value separator:

```shell
curl -X GET https://api.resourcewatch.org/v1/dataset?application=rw@gfw
```

Like in the case of sorting, most RW API resources allow filtering the returned results of list endpoints using query parameters. As a rule of thumb, you can use the API resource's fields as query parameter filters, as shown in the examples on the side. You can also combine different query parameters into a complex `and` logic filter. Note that you can achieve a logical `or` by passing a regular expression with two disjoint options, like this: `?name=<substr_a>|<substr_b>`.

For string type fields, the filter you pass will be interpreted as a regular expression, _not_ as a simple substring filter. This gives you greater flexibility in your search capabilities. However, it means that, if you intend to search by substring, you must escape any regex special characters in the string.

Array fields (like the `application` field present in some of the API resources - read more about the [application field](concepts.html#applications)) support more complex types of filtering. In such cases, you can use `,` as an `or` multi-value separator, or `@` as a multi-value, exact match separator.

Object fields expect a boolean value when filtering, where `true` matches a non-empty object and `false` matches an empty object. Support for filtering by nested object fields varies for different API resource, so be sure to check the documentation of the API endpoint for more detailed information.

Again, as in the case of sorting, keep in mind that it’s up to each individual RW API service (dataset, widget, layer, etc) to define and implement the filtering mechanisms. Because of this, the examples above may not be true for all cases. Refer to the documentation of each resource and endpoint for more details on filtering and the available fields to use as query parameter filters.

#### Which services comply with these guidelines

The following endpoints adhere to the Filtering conventions defined above:

* [Get all datasets endpoint](reference.html#getting-all-datasets)
* [Get all layers endpoint](reference.html#getting-all-layers)
* [Get all widgets endpoint](reference.html#getting-all-widgets)
* [Get all users endpoint](reference.html#getting-all-users)

repository: resource-watch/doc-api

repo_name: resource-watch/doc-api


text:
<!-- Do not edit this file. It is automatically generated by API Documenter. -->

[Home](./index.md) > [@google/vision](./vision.md) > [vision\_v1p2beta1](./vision.vision_v1p2beta1.md) > [Schema$Status](./vision.vision_v1p2beta1.schema_status.md)

## vision\_v1p2beta1.Schema$Status interface

The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by \[gRPC\](https://github.com/grpc). Each `Status` message contains three pieces of data: error code, error message, and error details.

You can find out more about this error model and how to work with it in the \[API Design Guide\](https://cloud.google.com/apis/design/errors).

<b>Signature:</b>

```typescript
export interface Schema$Status
```

## Properties

|  Property | Type | Description |
|  --- | --- | --- |
|  [code](./vision.vision_v1p2beta1.schema_status.code.md) | number \| null | The status code, which should be an enum value of google.rpc.Code. |
|  [details](./vision.vision_v1p2beta1.schema_status.details.md) | Array<{ \[key: string\]: any; }> \| null | A list of messages that carry the error details. There is a common set of message types for APIs to use. |
|  [message](./vision.vision_v1p2beta1.schema_status.message.md) | string \| null | A developer-facing error message, which should be in English. Any user-facing error message should be localized and sent in the google.rpc.Status.details field, or localized by the client. |

repository: octogonz/extractor-issues

repo_name: octogonz/extractor-issues


text:
# Using Cloudflare API to update a DNS A record with Edgerouter DDNS service

All this is already on the internet, and is a mix of several sources, but specially I put it here because of the "server" option, that caused me some headache.

NOTE: the A record (example.domain.com) MUST exist in Cloudflare BEFORE setting this.
You also need the Global API KEY from Cloudflare.

## Asumptioms and clarifications

   -  Your internet interface (i.e., the one with your changing public IP address) is eth0.
    - NOTE: If your ISP provides your service through a VLAN, it may be something like eth0.10. Please verify in the dashboard which interface name you need.
   - Your Cloudflare subdomain is example.domain.com
   - Your Cloudflare zone is domain.com
   - Your Cloudflare username is<EMAIL_ADDRESS>   - Your Cloudflare Global API KEY is 1234567abcdefg1234567
   - The name we will define for the service in the router is "custom-cloudflare"
   - You know how to connect to your router by SSH

## Commands for CLI (SSH)

```
configure

set service dns dynamic interface eth0 service custom-cloudflare host-name example.domain.com

set service dns dynamic interface eth0 service custom-cloudflare login<EMAIL_ADDRESS>
set service dns dynamic interface eth0 service custom-cloudflare password 1234567abcdefg1234567

set service dns dynamic interface eth0 service custom-cloudflare protocol cloudflare

set service dns dynamic interface eth0 service custom-cloudflare options "zone=domain.com use=web ssl=yes"

commit

save
```

### Note for old versions (<1.10.5)
You need to set also the server using:
```
set service dns dynamic interface eth0 service custom-cloudflare server api.cloudflare.com/client/v4/
```

## Verify status

```
show dns dynamic status
```

## Force an update

```
update dns dynamic interface eth0
```


text:
# Privacy Policy

Protecting your private information is our priority. This Statement of Privacy applies to visiontest.me and Vision Test Me and governs data collection and usage. For the purposes of this Privacy Policy, unless otherwise noted, all references to Vision Test Me include visiontest.me. The Vision Test Me website is a Ocular test for concussions and intoxication site. By using the Vision Test Me website, you consent to the data practices described in this statement.

### Collection of your Personal Information
In order to better provide you with products and services offered on our Site, Vision Test Me may collect personally identifiable information, such as your:

-	First and Last Name
-	Mailing Address
-	E-mail Address
-	Phone Number
-	Employer
-	Job Title
-	Various medical information and medical history

Vision Test Me may also collect anonymous demographic information, which is not unique to you, such as your:

-	Age
-	Gender
-	Race
-	Household Income

We do not collect any personal information about you unless you voluntarily provide it to us. However, you may be required to provide certain personal information to us when you elect to use certain products or services available on the Site. These may include: (a) registering for an account on our Site; (b) entering a sweepstakes or contest sponsored by us or one of our partners; (c) signing up for special offers from selected third parties; (d) sending us an email message; (e) submitting your credit card or other payment information when ordering and purchasing products and services on our Site. To wit, we will use your information for, but not limited to, communicating with you in relation to services and/or products you have requested from us. We also may gather additional personal or non-personal information in the future.

### Use of your Personal Information
Vision Test Me collects and uses your personal information to operate its website(s) and deliver the services you have requested.

Vision Test Me may also use your personally identifiable information to inform you of other products or services available from Vision Test Me and its affiliates.

Sharing Information with Third Parties
Vision Test Me may sell, rent, or lease customer information to third parties for the following reasons:

To provide clinical data to research organizations for improvement of concusion diagnostics

Vision Test Me may, from time to time, contact you on behalf of external business partners about a particular offering that may be of interest to you. In those cases, your unique personally identifiable information (e-mail, name, address, telephone number) is transferred to the third party. Vision Test Me may share data with trusted partners to help perform statistical analysis, send you email or postal mail, provide customer support, or arrange for deliveries. All such third parties are prohibited from using your personal information except to provide these services to Vision Test Me, and they are required to maintain the confidentiality of your information.

Vision Test Me may disclose your personal information, without notice, if required to do so by law or in the good faith belief that such action is necessary to: (a) conform to the edicts of the law or comply with legal process served on Vision Test Me or the site; (b) protect and defend the rights or property of Vision Test Me; and/or (c) act under exigent circumstances to protect the personal safety of users of Vision Test Me, or the public.

### Tracking User Behavior
Vision Test Me may keep track of the websites and pages our users visit within Vision Test Me, in order to determine what Vision Test Me services are the most popular. This data is used to deliver customized content and advertising within Vision Test Me to customers whose behavior indicates that they are interested in a particular subject area.

Pupil tracking

### Automatically Collected Information
Information about your computer hardware and software may be automatically collected by Vision Test Me. This information can include: your IP address, browser type, domain names, access times and referring website addresses. This information is used for the operation of the service, to maintain quality of the service, and to provide general statistics regarding use of the Vision Test Me website.

### Use of Cookies
The Vision Test Me website may use "cookies" to help you personalize your online experience. A cookie is a text file that is placed on your hard disk by a web page server. Cookies cannot be used to run programs or deliver viruses to your computer. Cookies are uniquely assigned to you, and can only be read by a web server in the domain that issued the cookie to you.

One of the primary purposes of cookies is to provide a convenience feature to save you time. The purpose of a cookie is to tell the Web server that you have returned to a specific page. For example, if you personalize Vision Test Me pages, or register with Vision Test Me site or services, a cookie helps Vision Test Me to recall your specific information on subsequent visits. This simplifies the process of recording your personal information, such as billing addresses, shipping addresses, and so on. When you return to the same Vision Test Me website, the information you previously provided can be retrieved, so you can easily use the Vision Test Me features that you customized.

You have the ability to accept or decline cookies. Most Web browsers automatically accept cookies, but you can usually modify your browser setting to decline cookies if you prefer. If you choose to decline cookies, you may not be able to fully experience the interactive features of the Vision Test Me services or websites you visit.

### Links
This website contains links to other sites. Please be aware that we are not responsible for the content or privacy practices of such other sites. We encourage our users to be aware when they leave our site and to read the privacy statements of any other site that collects personally identifiable information.

### Security of your Personal Information
Vision Test Me secures your personal information from unauthorized access, use, or disclosure. Vision Test Me uses the following methods for this purpose:

-	SSL Protocol
-	Verisign

When personal information (such as a credit card number) is transmitted to other websites, it is protected through the use of encryption, such as the Secure Sockets Layer (SSL) protocol.

We strive to take appropriate security measures to protect against unauthorized access to or alteration of your personal information. Unfortunately, no data transmission over the Internet or any wireless network can be guaranteed to be 100% secure. As a result, while we strive to protect your personal information, you acknowledge that: (a) there are security and privacy limitations inherent to the Internet which are beyond our control; and (b) security, integrity, and privacy of any and all information and data exchanged between you and us through this Site cannot be guaranteed.

### Children Under Thirteen
Vision Test Me collects personally identifiable information from children under the age of thirteen. Vision Test Me collects this information for the following reason(s): For improvement of concussion diagnosis for younger individuals..

We provide information about our personal data practices for children on our home page and wherever we knowingly collect personal data from children on our Web site. If you are under the age of thirteen, you must ask your parent or guardian for permission to use this website. If you are a parent and you have questions regarding our data collection practices, please contact us using the information provided at the end of this Statement of Privacy.

### Opt-Out & Unsubscribe from Third Party Communications
We respect your privacy and give you an opportunity to opt-out of receiving announcements of certain information. Users may opt-out of receiving any or all communications from third-party partners of Vision Test Me by contacting us here:
- Web page: visiontest.me/optout
- Email<EMAIL_ADDRESS>
### E-mail Communications
From time to time, Vision Test Me may contact you via email for the purpose of providing announcements, promotional offers, alerts, confirmations, surveys, and/or other general communication.

If you would like to stop receiving marketing or promotional communications via email from Vision Test Me, you may opt out of such communications by<EMAIL_ADDRESS>

### External Data Storage Sites
We may store your data on servers provided by third party hosting vendors with whom we have contracted.

### Changes to this Statement
Vision Test Me reserves the right to change this Privacy Policy from time to time. We will notify you about significant changes in the way we treat personal information by sending a notice to the primary email address specified in your account, by placing a prominent notice on our site, and/or by updating any privacy information on this page. Your continued use of the Site and/or Services available through this Site after such modifications will constitute your: (a) acknowledgment of the modified Privacy Policy; and (b) agreement to abide and be bound by that Policy.

### Contact Information
Vision Test Me welcomes your questions or comments regarding this Statement of Privacy. If you believe that Vision Test Me has not adhered to this Statement, please contact Vision Test Me at:

Vision Test Me
4855 Kipling Dr
Carmichael, California 95608

Email Address:
<EMAIL_ADDRESS>
Telephone number:
9168024783

Effective as of May 31, 2018

repository: visiontestme/legal

repo_name: visiontestme/legal


text:
# CallSharp
Helper tool for inferring function call chains dependent on input and expected output.

This is a self-updating app; to install it, click here.

## Very tentative roadmap

**0.1** Initial release; search works but takes an atrocious amount of time.

**0.2** Search speed improvements (static API search).

** WE ARE HERE **

**0.3** Omission fixes: operators, properties, indexers, verification of constructor calls, support for generics.

tbc.

repository: jlollis/CallSharp

repo_name: jlollis/CallSharp