text:
---
abstract: Django’s ORM is probably its most-used but also least-understood component.
  This lecture-format tutorial will try to fix that, by teaching you best practices
  for using the ORM, advanced features you might not have known about, and technical
  details of how it works under the hood (as of Django 2.2).
accepted: true
category: tutorials
date: 2020-10-11 13:30:00 -0500
difficulty: Intermediate
end_date: 2020-10-11 17:00:00 -0500
image: /static/img/social/presenters/james-bennett.png
layout: session-details
permalink: /tutorials/mastering-the-django-orm/
presenters:
- james-bennett
published: true
room: Balboa I & II
sitemap: true
slides_url: ''
summary: ''
tags:
- database
- sql
- orm
- models
title: Mastering the Django ORM
track: t0
video_url: ''
---

This is a lecture-format tutorial which will cover the Django ORM in
depth; it's designed to be accessible to anyone who's worked through
an introductory Django tutorial, but intermediate and other slightly
more experienced users of Django will probably get the most out of it.

The material breaks down roughly as follows.

Fundamentals: exploring the concept of ORMs in general, arguments for
and against their use, including both known advantages -- like safer,
more portable and less tedious code for common query patterns -- and
known shortcomings such as the infamous "object-relational impedance
mismatch". From there, a look at the two major patterns of ORM design,
Data Mapper and Active Record, and a brief study of the history of
Django's ORM, including the high-level design choices which have gone
into it.

A basic tour of the ORM: this material may be remedial for some
attendees, but will re-introduce the major developer-facing components
of the Django ORM and their purposes, to ensure familiarity for later
sections.

Going beyond the basics, part 1: best practices for model design and
layout. Topics covered here will include: normal forms and the
advantages/disadvantages of various types of normalization; models and
their managers as the primary place to put "business logic" and as the
main public API of a Django application; using custom field types for
richer data modeling and validation; patterns for common model-design
issues like handling choices/enums; discussion of the various model
inheritance options supported in the Django ORM and their pros/cons;
understanding the migration framework and what can be done with
hand-written migrations; and custom user models.

Going beyond the basics, part 2: intermediate and advanced features
and patterns for working with your database. This will begin with an
exploration of some common querying pitfalls and how to prevent them,
and proceed from there into topics such as: performance optimization
through controlling exactly what Django will query for, including how
to skip loading entire result sets and instantiating all their model
objects; working with Q and F objects to build more complex queries;
annotation and aggregation patterns; the query expression API and how
to write custom expression and function wrappers to push functionality
out of Python code and into your database; using and wrapping
database-level views from the ORM; understanding and controlling
transaction behavior; and implementing and taking advantage of
advanced/custom indexes and constraints. This section will end with a
tour of the "danger zone": features of the ORM which often are more
trouble than they're worth, and how the previously-covered material
suggests alternatives or replacements for them.

Under the hood: a deep technical dive into the internals of the
ORM. The original high-level tour of the ORM's components will be
revisited, this time delving into how each component is
implemented. This section will cover the model metaclass and model
introspection API; the base Manager and QuerySet classes and their
relationships to each other; the structure of the underlying Query
object and useful methods on it; SQL compilers and how they process
and transform a Query; and the structure of Django's database backend
modules. Finally, this section and the main tutorial will conclude
with a full walkthrough of a query, starting from the model class and
tracing it all the way "down" the stack through each component, into
the database, and then back "up" the ORM's component stack to the
resulting QuerySet of model instances.

Time remaining past this point will be used for Q&A, but attendees
will also be encouraged to ask questions throughout the entire
session, including dedicated question breaks at the end of each
section.


text:
# Playgrounds

[![Code Style Prev](https://img.shields.io/badge/code%20style-prev-32c8fc.svg)](https://github.com/preco21/eslint-config-prev)
[![Build Status](https://travis-ci.org/preco21/playgrounds.svg?branch=master)](https://travis-ci.org/preco21/playgrounds)
[![Dependency Status](https://dependencyci.com/github/preco21/playgrounds/badge)](https://dependencyci.com/github/preco21/playgrounds)

> Yay! :rocket:

A minimal setup for writing ES2015+ code.

* Babel configuration that contains preset `env (current)`, `stage-1` and `minify` (used in production build).
* Live-reloading code with `nodemon` and `babel-node`.
* Debugging with [Chrome DevTools](https://medium.com/@paul_irish/debugging-node-js-nightlies-with-chrome-devtools-7c4a1b95ae27) out of box.
* Package up your app with `pkg`.

## Install

```bash
$ git clone https://github.com/preco21/playgrounds.git
$ cd playgrounds
$ npm install
```

## Usage

### Development mode

This command executes `nodemon` demon for _live-reloading_ experiences. Once the daemon started, you can start editing `index.js` in `src` folder!

```bash
$ npm run dev
```

### Development mode with Chrome DevTools

You may be heard about [Node.js V8 Inspector Integration](https://nodejs.org/api/debugger.html#debugger_v8_inspector_integration_for_node_js) which allows you to attach your Node.js application to Chrome DevTools for better debugging and profiling. To use this fantastic feature, make sure you are running **Node.js 6+** and **Chrome 60+**, then go to the Chrome inspector page first:

> [chrome://inspect/#devices](chrome://inspect/#devices)

Then click the `Open dedicated DevTools for Node` link to open devtools, run following command:

```bash
$ npm run dev-inspect
```

Now you can place `debugger` keyword in your code to specify breakpoints:

```js
function foo(a, b) {
  return a * b;
}

const bar = foo(1, 2);
debugger;
```

**Note:** You can also use `npm run dev-inspect-brk` to break before the code starts.

#### References

* [Debugging Node.js with Chrome DevTools](https://medium.com/@paul_irish/debugging-node-js-nightlies-with-chrome-devtools-7c4a1b95ae27)
* [Debugging Node.js with Google Chrome](https://medium.com/the-node-js-collection/debugging-node-js-with-google-chrome-4965b5f910f4)
* [Can I get node --inspect to open Chrome automatically](https://stackoverflow.com/questions/41398970/can-i-get-node-inspect-to-open-chrome-automatically)

### Build

This command builds your source code with Babel from `src` into `lib`.

```bash
$ npm run build
```

After building the code, you will be able to run the built code like standalone version of the application:

```bash
npm start
```

### Packaging

You can also create standalone executables with this command, which will generate the executables in `bin` folder:

```bash
$ npm run package
```

The generated app can be executed without any runtime dependencies.

### Clean

This command cleans the build output directory. This command will remove any content inside `lib` folder.

```base
$ npm run clean
```

## License

[MIT](https://preco.mit-license.org/)

license: MIT

repository: saeedhei/playgrounds

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: saeedhei/playgrounds


text:
---
layout: blog-post
draft: false
date: 2020-02-25T17:58:01.302Z
title: 'RxJS Hooks and Suspense: The Ultimate Guide'
description: >-
  In witch I suggested a simple, flexible, testable and performant solution to
  use RxJS Observable with React hooks and Suspense.
quote:
  author: William Shakespeare
  content: 'We are time''s subjects, and time bids be gone.'
  source: ''
tags:
  - RxJS
  - JavaScript
  - React
---
(This post is also on [medium](https://medium.com/@straybugs/rxjs-hooks-and-suspense-the-ultimate-guide-6d4f61dc224c))

## Why Hooks

Stateful logic is unavoidable in any React project. In early days we used the `state` property in Class-Components to hold stateful values.

### "This" isn't the way

But quickly we realized that it is prone to lose track of states in "this" way. So we divided Components into stateful(smart) Components and stateless(dumb) Components. Stateful logic is delegated to parent stateful Components to keep most Components stateless.

This does not solve the issue, just makes it less painful.

### Time travelling

Then came the age of Redux(and MobX etc.). We started to put states into central stores which can be tracked with devtools and stuff.

This does not solve the issue, just delegates it to outside stores.

Introducing stores is acceptable for a full project but would be too bloated for developing reusable stateful Components.

### Get on the Hook

React Hooks fills this gap by offering a mechanism that connects side-effects separately within the Component.

For stateful logic it is like connecting to many mini-stores within the Component. Side-effect code with hooks is compact, reusable and testable.

Hooks is an attempt to solve the issue. It is delicate and not perfect but it is the best we have so far.

For more about hooks see the [React Docs](https://reactjs.org/docs/hooks-intro.html).

## Why RxJS in Hooks

Since React hooks opens a door of reusing side-effect logic within Components, it is tempting to reuse complicated asynchronous logic like remote data fetching, intricate animation or device input sequence interpretation.

One of the most popular ways to manage complicated asynchronous logic is [Reactive Programming](https://en.wikipedia.org/wiki/Reactive_programming), a language-independent declarative programming paradigm concerned with data streams and the propagation of change. RxJS, part of the ReactiveX(Reactive Extensions), is a JavaScript implementation of reactive programming.

There are also libraries that focus only on a few specific asynchronous scenarios, like [swr](https://github.com/zeit/swr) for remote data fetching. This is like comparing Redux Saga with Redux Observable. The knowledge you gain from learning how to use these libraries is not as transferable as RxJS and Reactive Programming.

Yes there is a learning curve on RxJS but that is mostly a one-time conceptual thing. Don't be scared by the number of RxJS opertators. You most likely only need a few of them. Also see the [Operator Decision Tree](https://rxjs-dev.firebaseapp.com/operator-decision-tree).

## Observable Hooks

We first tried [rxjs-hooks](https://github.com/LeetCode-OpenSource/rxjs-hooks) but quickly encountered some [tricky TypeScript issues](https://github.com/LeetCode-OpenSource/rxjs-hooks/issues/60). We also think the `useEventCallback` is [taking too much responsibilities](https://github.com/LeetCode-OpenSource/rxjs-hooks/blob/505d71901a9ca7827472d750455d44e5bc3d9f48/src/use-event-callback.ts#L77-L80) which is a performance issue that is hard to fix due to [rules of hooks](https://reactjs.org/docs/hooks-rules.html#only-call-hooks-at-the-top-level).

Unfortunately the project is not actively developed as the team has shifted focus to the redux-observable-like [ayanami](https://github.com/LeetCode-OpenSource/ayanami) project.

Ultimately we rethought the whole integration, redesigned API from the ground up and created [observable-hooks](https://observable-hooks.js.org) for connecting RxJS Observable to React Components.

A simple example(more on the [docs](https://observable-hooks.js.org/examples/#conditional-rendering-vanilla-javascript)):

```javascript
import React from 'react'
import { useObservableState } from 'observable-hooks'
import { timer } from 'rxjs'
import { switchMap, mapTo, startWith } from 'rxjs/operators'

const App = () => {
  const [isTyping, updateIsTyping] = useObservableState(
    event$ => event$.pipe(
      switchMap(() =>
        timer(1000).pipe(
          mapTo(false),
          startWith(true)
        )
      )
    ),
    false
  )

  return (
    <div>
      <input type="text" onKeyDown={updateIsTyping} />
      <p>{isTyping ? 'Good you are typing.' : 'Why stop typing?'}</p>
    </div>
  )
}
```

![observable-hooks](https://github.com/crimx/observable-hooks/raw/master/observable-hooks.png?raw=true)

By decoupling states, events and Observables it no longer makes unused resources run idle.

Logic lives in pure function which improves reusability and testability.

See the docs for more about [core concepts](https://observable-hooks.js.org/guide/core-concepts.html) and [API](https://observable-hooks.js.org/api/).

Pomodoro Timer Example:

<iframe title="Pomodoro Timer Example" allow="geolocation; microphone; camera; midi; vr; accelerometer; gyroscope; payment; ambient-light-sensor; encrypted-media; usb" sandbox="allow-modals allow-forms allow-popups allow-scripts allow-same-origin" src="https://codesandbox.io/embed/github/crimx/observable-hooks/tree/master/examples/pomodoro-timer?autoresize=1&fontsize=14&hidenavigation=1&theme=dark" style="width:100%;height:500px;border:1px solid #ebedf0;background-color:#ebedf0;border-radius:4px;overflow:hidden;">

## Suspense

With the experimental [React Suspense](https://reactjs.org/docs/concurrent-mode-suspense.html) asynchronous resources can be read declaratively like it has already been resolved.

Since Suspense is just a mechanism it is possible to convert Observables into Suspense compatible resources ([benefits of observable as data source](https://observable-hooks.js.org/guide/render-as-you-fetch-suspense.html#benefits-of-observable-as-data-source)).

<iframe title="Render-as-You-Fetch (using Suspense)" allow="geolocation; microphone; camera; midi; vr; accelerometer; gyroscope; payment; ambient-light-sensor; encrypted-media; usb" sandbox="allow-modals allow-forms allow-popups allow-scripts allow-same-origin" src="https://codesandbox.io/embed/github/crimx/observable-hooks/tree/master/examples/suspense?autoresize=1&fontsize=14&hidenavigation=1&theme=dark" style="width:100%;height:500px;border:1px solid #ebedf0;background-color:#ebedf0;border-radius:4px;overflow:hidden;">

Observable-hooks offers [`ObservableResource`](https://observable-hooks.js.org/api/suspense.html#observableresource) to do the trick.

```javascript
// api.js
import { ObservableResource } from 'observable-hooks'

const postResource$$ = new Subject()

export const postsResource = new ObservableResource(postResource$$.pipe(
  switchMap(id => fakePostsXHR(id))
))

export function fetchPosts(id) {
  postResource$$.next(id)
}
```

Resources are consumed with [`useObservableSuspense`](https://observable-hooks.js.org/api/suspense.html#useobservablesuspense).

```javascript
// App.jsx
import { useObservableSuspense } from 'observable-hooks'

import { postsResource, fetchPosts } from './api'

fetchPosts('crimx')

function ProfilePage() {
  return (
    <Suspense fallback={<h1>Loading posts...</h1>}>
      <ProfileTimeline />
    </Suspense>
  )
}

function ProfileTimeline() {
  // Try to read posts, although they might not have loaded yet
  const posts = useObservableSuspense(postsResource)
  return (
    <ul>
      {posts.map(post => (
        <li key={post.id}>{post.text}</li>
      ))}
    </ul>
  )
}
```

## Conclusion

The API of observable-hooks is really simple and flexible. Folks who love both React and RxJS I highly recommend you give it a try.

What do you think? Please let us know by leaving a comment below!

gha_language: JavaScript

gha_license_id: MIT


text:
---
layout: post
title: Underscore.string 2.0 release
date: 2011-11-09
comments: true
categories: underscore js
---

## Why 2.0?

In this version we moved Underscore.string library to separate namespace _.string
for solve name conflicts with Underscore library. There are some functions that available in
both libraries, for ex. include and reverse. In 1.1.6 and lower Underscore.string provided includes
function, but we decided that two function include and (includes or includeString) in one namespace
and with same functionality but one function for collections another for strings, it's a little bit ugly.

## Do we always need to write _.string?

Nope. Underscore.string provide exports function _.string.exports(), this function returns only non-conflict functions and we can mix in these functions to Underscore scope if you want.

``` js
_.mixin(_.string.exports());

// Access to Underscore.string and Underscore functions
_.include([1,2,3], 1)
_.trim('  asd  ')

// Access to conflict Underscore.string functions
_.string.include('foobar', 'bar')
// or
_.str.include('foobar', 'bar')
// "str" it's just alias for "string"
```

## Problems
We lose two things for include and reverse methods from _.string:

* Calls like `_('foobar').include('bar')` aren't available;
* Chaining isn't available too.

But if you need this functionality you can create aliases for conflict functions which will be convnient for you.

``` js
_.mixin({
    includeString: _.str.include,
    reverseString: _.str.reverse
})

// Now wrapper calls and chaining are available.
_('foobar').chain().reverseString().includeString('rab').value()
```

## Standalone Usage
If you are using Underscore.string without Underscore. You also have _.string namespace for it. And current version number you can find through VERSION constant _.string.VERSION. If you want you can just reassign _ variable with _.string

``` js
_ = _.string

_.VERSION // => 1.2.0
```

## Node.js Installation

``` js
npm install underscore.string
```

### Standalone usage:

``` js
var _s = require('underscore.string');
```

### Integrate with Underscore.js:

I recommend you this way for integrating with Underscore.js:

``` js
var _  = require('underscore');

// Import Underscore.string to separate object, because there are conflict functions (include, reverse, contains)
_.str = require('underscore.string');

// Mix in non-conflict functions to Underscore namespace if you want
_.mixin(_.str.exports());

// All functions, include conflict, will be available through _.str object
_.str.include('Underscore.string', 'string'); // => true
```

## Upgrade
In new version function includes has been removed, you should replace this function by _.str.include or create alias _.includes = _.str.include and all will work fine.

## Peace!

extension: markdown


text:
# Uncertain index datasets

## Documentation

```@docs
UncertainIndexDataset
```

## Description

`UncertainIndexDataset`s is an uncertain dataset type that represents the indices
corresponding to an [UncertainValueDataset](uncertain_value_dataset.md).

It is meant to be used for the `indices` field in
[UncertainIndexValueDataset](uncertain_indexvalue_dataset.md)s instances.

## Defining uncertain index datasets

### Example 1: increasing index uncertainty through time

#### Defining the indices

Say we had a dataset of 20 values for which the uncertainties are normally distributed
with increasing standard deviation through time.

```julia
time_inds = 1:13
uvals = [UncertainValue(Normal, ind, rand(Uniform()) + (ind / 6)) for ind in time_inds]
inds = UncertainIndexDataset(uvals)
```

That's it. We can also plot the 33rd to 67th percentile range for the indices.

```plot
plot(inds, [0.33, 0.67])
```

![](uncertain_indexvalue_dataset_indices.svg)

gha_language: Julia


text:
# Enable Twitter Cards

When you want to start using Twitter cards you have to whitelist your domain through the Twitter cards validator. Once your domain is validated you are all set.

**Note:** when you change your cardtype, you have to revalidate.

## Validate your domain

* Visit the [Twitter cards validator service](https://cards-dev.twitter.com/validator).
* Enter a url which contains the Twitter cards meta tags. By default, the only suitable URL is a detail page of the Blog module.
* Fill out the form and submit.
* You will receive an e-mail when Twitter has completed your validation.

Once you have completed the steps above you will be able to use Twitter cards on your website.

repository: forkcms/forkcms

path: /docs/02. getting started/06. enable_twittercards.md

filename: 06. enable_twittercards.md

gha_language: PHP

repo_name: forkcms/forkcms


text:
# Deep Learning

Currently on pause ... will be back soon.

This repo is about the book https://www.deeplearningbook.org/ by Ian Goodfellow *et al*. It contains jupyter notebooks, which you can also run on Google Colab.

## Troubleshooting

The best way to find and solve your problems is to see in the github issue tab. If you can't find what you want, feel free to raise an issue. We are pretty responsive.

## Cite our work

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

## Contributing

Contributions are what make the open source community such an amazing place to be learn, inspire, and create. Any contributions you make are **greatly appreciated**.

1. Fork the Project
2. Create your Feature Branch (`git checkout -b feature/AmazingFeature`)
3.  Push to the Branch (`git push origin feature/AmazingFeature`)
5. Open a Pull Request

## License
[MIT](https://choosealicense.com/licenses/mit/)

## Authors
[Taewoon Kim](https://taewoon.kim/)


text:
---
layout: single
title: "Magic"
permalink: /concepts/magic/
author_profile: false
header:
  sub: "concepts-subheader"
---

{% include toc title="Magic" icon="file-text" %}

## Power of the Waves
### Two Kinds
There exist two kinds of magic in Myrmagir which are
 - Internal or Elemental Magic and
 - External or Free Magic

The difference lies in the usage of the Astralwave, as it can either store elementals in itself or resonate with and therefore manipulate other waves.
## External / Free Magic
As the External Magic means to manipulate other waves, it means to add or take energy from them and so changing the world around. But as adding energy means that energy is required, the magicians give their own energy or lifeforce and can even kill themselves when overdoing it (see Gamemechanics for more information).
### Inject or Extract
Respectively adding and taking energy means to strengthen or weaken an amplitude of a wave. As most of the matter is in constant movement if not absolute cold, it can also be for example heatened up of cooled down.
### Change
Mostly in their later years of learning how to use the resonance within themselves, magicians acquire the first knowledge of how to change the amplitude patterns in the waves to change matter into another kind of matter or a force into another force.
It takes a lot of energy and concentration to do this and is thus a highly respected kind of magic.
### Create and Vary
The most dangerous and difficult variation of external magic is the one of creation, using the own energy to have a wave break through the space and materialize.
Also, creating a new matter through experimentation with the change of amplitude patterns into yet undiscovered ones can be a high risk for anyone trying to do this as the attributes of the new patterns and the results of the new creation can be disastrous.
## Internal / Elemental Magic
Elemental magicians absorb elementals into their Astralwave to use their power in exchange of small portions of the magicians own energy.
After their absorption their power can be activated and then for one thing make the wielder immune to it, depending on how many elementals are taken and also be used as a weapon or to fusion with another elemental.
For another it can give the wielders the power of the elemental to empower the own body and later be used to empower and enlarge their auras to change their direct environment.
### Elementals
Elementals are creatures of Myrmagir that are created randomly as strong amplitude patterns appearing around mostly something that has to do with the power inhabiting them.
## The Combination
The fusion of the two kinds of magic is called energetical magic and can be used to combine the power of both kinds of magic into one.
Using the low energy consumption and easy creation of forces via the power of elementals combined with the influence of free magic on other objects outside of the body brings endless possibilities to experiment and practically usages.
## Storing Energy
Elementals can be stored in any object or even living beings, since the astralwave is in every connection of amplitudes on the matterwave even though in most not endlessly. But energy itself can just be stored in objects or taken away from other living beings.
For example on places for rites where magic is working on for Ions, special objects are used that take energy from around themselves to feed the elementals in them.


text:
# Debugging linking errors

The usual utilties like `nm`, `objdump` and of course `ldd` (see
[here](https://linux-audit.com/elf-binaries-on-linux-understanding-and-analysis/#tools-for-binary-analysis)
for a good overview of existing tools) go a long way, but when
debugging non-trivial runtime linker failures one would often like to
filter outputs programmatically with more than just simple `grep` and
`sed` expressions.

This library provides a small set of utility subroutines that can help
debug complicated linker errors.

The main function is `ldd(f, elf_path)`, which is in the same spirit
as `ldd(1)`, but returns a tree of shared dependencies instead of a
flat list. Additionally, it expects a function `f` which is applied to
each recursion level of dependencies.

Functions that can be passed to `ldd`:

- `identity`: pass through every info `ldd` can output
- `remove_uninteresting_dependencies`: remove entries that are mostly noise
- `was_runpath_used`: return a list of unused runpaths

Helpers:
- `dict_remove_empty`: remove fields with empty lists/dicts from an output

Example usage:

```python
import pprint
from bazel_tools.tools.python.runfiles import runfiles
from debug.linking_utils.ldd import \
  ldd, \
  was_runpath_used, \
  dict_remove_empty, \
  remove_unnecessary_dependencies

r = runfiles.Create()
pp = pprint.PrettyPrinter(indent=2)

pp.pprint(
  ldd(remove_uninteresting_dependencies, path)
)

print("\nUnused RUNPATH entries:")
pp.pprint(
  dict_remove_empty(
    ldd(was_runpath_used, path)['others']
  )
)
```


text:
# Leptoporus conchoides (Mont.) Pat., 1903 SPECIES

#### Status
SYNONYM

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

#### Published in
in Duss, Enum. Champ. Guadeloupe (Lons-le-Saunier) 27 (1903)

#### Original name
Gloeoporus conchoides Mont., 1842

### Remarks
null

repository: mdoering/backbone

path: /life/Fungi/Basidiomycota/Agaricomycetes/Polyporales/Meruliaceae/Gloeoporus/Gloeoporus thelephoroides/ Syn. Leptoporus conchoides/README.md

repo_name: mdoering/backbone


text:
# Installation of the Chat Bot

1. If you don't have it already, install [Node.JS and npm](nodejs.org), this bot requires at least Node.JS 8.x.x
1. run `npm i` to install all dependencies
1. You'll need a Twitch IRC password, you can learn how to get one [from the docs](https://dev.twitch.tv/docs/authentication/) or they have a quick-use [password generator](https://twitchapps.com/tmi/)
1. You will also need an [Adafruit.IO](https://adafruit.io) account. They have a free tier. You will need to copy your adafruit.io key (click the 'View AIO Key' link in the left menu), and the feed you will use to communicate with your bot. On the feed page, click 'Feed Information' on the right and copy the value for 'MQTT by Key'.
1. Create a .env file in the chatbot directory that contains the following:

```
TWITCH_IRC_PASSWORD=your_twitch_IRC_password
TWITCH_IRC_ROOM=usually_your_twitch_username
TWITCH_USERNAME=your_twitch_username
AIO_KEY=your_adafruit_IO_key
AIO_FEED=your_adafruit_IO_MQTT_key
```

1. run `node index.js` to run the chat bot. Make sure the [hardware](../botbot/README.md) is running as well!

license: Unlicense

repository: nodebotanist/lightsbot-twitch

repo_name: nodebotanist/lightsbot-twitch


text:
# connect-monkeyglitch

 A monkeyglitch middleware for [Connect](http://github.com/senchalabs/connect).

## Example

```js
var connect = require('connect');
var monkeyglitch = require('connect-monkeyglitch');

connect(
    connect.logger()
  , monkeyglitch(__dirname + '/public')
  , function(req, res) {
    res.setHeader('Content-Type', 'text/html');
    res.end('<img src="/001.jpg" /><img src="/002.gif" /><img src="/003.png" />');
  }
).listen(3001);
```

![example_result](https://github.com/koyachi/connect-monkeyglitch/raw/master/examples/example_result.png)

## about "Monkey Glitch"

- [Visual Glitch, using Ruby | RubyKaigi 2011(July 16 - 18)](http://rubykaigi.org/2011/en/schedule/details/18S02)
- [蒸し蒸しした曇り空 - ずっと君のターン](http://d.hatena.ne.jp/technohippy/20110806#1312604810)
- [youpy/rack-middleware-glitch - GitHub](https://github.com/youpy/rack-middleware-glitch)

## License

(The MIT License)

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

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

THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

repository: koyachi/connect-monkeyglitch

repo_name: koyachi/connect-monkeyglitch


text:
Python 3rdparty Pattern
=======================

In general, we use the
[[3rdparty idiom|pants('src/docs:3rdparty')]] to organize
dependencies on code from outside the source tree. This document
describes how to make this work for Python code.

Your Python code can pull in code written elsewhere. Pants fetches code
via a library that uses pip-style specifications (name and
version-range).

3rdparty/python
---------------

To keep all of your code depending on the same versions of third-party
Python artifacts, you might use the idiom of keeping them in a directory
tree under `3rdparty/python`. If your organization has many such
dependencies, you might arrange them in several directories: this can
ease later "git detective work" when finding out who changed a version.
(Pants itself doesn't have many Python dependencies; thus, we haven't split its `3rdparty` tree
into many directories.)

**pip-style requirements.txt:**

To define some third-party dependencies, use a
`python_requirements` in your `BUILD`
file and make a pip `requirements.txt` file in the same directory.

E.g, your `3rdparty/python/BUILD` file might look like:

!inc[start-at=python_requirement&end-before=#](../../../../3rdparty/python/BUILD)

...with `3rdparty/python/requirements.txt` like:

!inc[end-before=pathspec](../../../../3rdparty/python/requirements.txt)

`python_requirements` defines a named target for each line in the
`requirements.txt` line. For example, a line like `ansicolors==1.0.2` in
`requirements.txt` defines a target named `ansicolors` that pulls in
ansicolors version 1.0.2.

**python\_requirement\_library and python\_requirement:**

A `BUILD` file can also define requirements without a `requirements.txt`
file. Set up a
`python_requirement_library`
with one or more
`python_requirement`s
like:

    :::python
    python_requirement_library(
      name='beautifulsoup',
      requirements=[
        python_requirement(name='beautifulsoup',
                           requirement='BeautifulSoup==3.2.0'),
      ])

Your Code's BUILD File
----------------------

In your code's `BUILD` file, introduce a dependency on the `3rdparty`
target:

!inc[start-at=python_library](hello/greet/BUILD)

Then in your Python code, you can `import` from that package:

    :::python
    from colors import green

Managing dependencies for multiple platforms
----------------------

If you're building a python binary for use on multiple platforms, you might have 3rd-party
dependencies that rely on platform-specific code. In addition to specifying the platforms
with which your binary is intended to be compatible in the `platforms` field of your
`python_binary` target, you will need to make
wheel files for each package
and platform available at build time.

Pants will look for those files in the location specified in the
[[`python-repos`|pants('src/docs:setup_repo')#redirecting-python-requirements-to-other-servers]] field
in pants.ini. It can understand either a simple local directory of .whl files or a "find links"-friendly
webpage of links formatted like so:

```
<a href="x.whl">x.whl</a>
```

If you opt for the local directory method under version control, you may want to use
git-lfs or similar to avoid storing large binaries in your
repository. If you opt for a hosted solution, Github pages may
be helpful.

repository: foursquare/pants

gha_language: Python

repo_name: foursquare/pants


text:
# GitHubV3RestApi.InlineObject119

## Properties

Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**ignored** | **Boolean** | Determines if all notifications should be blocked from this repository. | [optional]
**subscribed** | **Boolean** | Determines if notifications should be received from this repository. | [optional]


text:
---
id: q5
question: What do I need to do to become a Farmer?
---

All you need to become a farmer is a 3Node, electricity and network connection.

There are two ways to get a 3Node:
- by purchasing a Plug & Play 3Node
- by building your own (DIY)

The ThreeFold Foundation and ThreeFold Farming Cooperatives around the world are providing Plug & Play 3Nodes that are already booted by Zero-OS, permitting anyone to just order and connect a 3Node to the Threefold Grid without the need for technical knowledge.

Nevertheless almost any reasonably modern 64-bit computer with an Intel or AMD processor, running ThreeFold’s Zero OS can be turned into a 3Node. The team has had some success testing ARM based devices as well, and that can be expected as another option in the future.

branch_name: refs/heads/development

gha_language: Vue


text:
# libroute
A framework for scientific, engineering and compute applications

## Overview
This repository contains the libroute core application.

## Installation
To run this application as a standalone server, visit the [libroute stack](https://github.com/libroute/libroute-stack) repository.

## Documentation
Visit [libroute.io](https://libroute.io) for full documentation

repository: libroute/libroute

repo_name: libroute/libroute


text:
# Legion

[Legion](http://legion.stanford.edu) is a parallel programming model
for distributed, heterogeneous machines.

## Branches

The Legion team uses this repository for active development, so please make sure you're
using the right branch for your needs:

  * stable - This is the default branch if you clone the
repository.  It is generally about a month behind the master branch, allowing us to get some
mileage on larger changes before foisting them on everybody.  Most users of Legion should use this
branch, although you should be prepared to try the master branch if you run into issues.
Updates are moved to the stable branch roughly monthly, although important bug fixes may be
applied directly when needed.  Each batch of updates is given a "version" number, and
[CHANGES.txt](https://github.com/StanfordLegion/legion/blob/stable/CHANGES.txt) lists the
major changes.
  * master - This is the "mainline" used by the Legion team,
and contains changes and bug fixes that may not have made it into the stable branch yet.  If you
are a user of "bleeding-edge" Legion functionality, you will probably need to be using this branch.
  * lots of other feature branches - These exist as necessary for larger changes, and users will
generally want to steer clear of them.  :)

## Overview

Legion is a programming model and runtime system designed for decoupling the specification
of parallel algorithms from their mapping onto distributed heterogeneous architectures.  Since
running on the target class of machines requires distributing not just computation but data
as well, Legion presents the abstraction of logical regions for describing the structure of
program data in a machine independent way.  Programmers specify the partitioning of logical
regions into subregions, which provides a mechanism for communicating both the independence
and locality of program data to the programming system.  Since the programming system
has knowledge of both the structure of tasks and data within the program, it can aid the
programmer in host of problems that are commonly the burden of the programmer:

  * Discovering/verifying correctness of parallel execution: determining when two tasks
    can be run in parallel without a data race is often difficult.  Legion provides mechanisms
    for creating both implicit and explicit parallel task launches.  For implicit constructs
    Legion will automatically discover parallelism.  For explicit constructs, Legion will
    notify the programmer if there are potential data races between tasks intended to be
    run in parallel.
  * Managing communication: when Legion determines that there are data dependencies between
    two tasks run in different locations, Legion will automatically insert the necessary
    copies and apply the necessary constraints so the second task will not run until
    its data is available.  We describe how tasks and data are placed in the next paragraph
    on mapping Legion programs.

The Legion programming model is designed to abstract computations in a way that makes
them portable across many different potential architectures.  The challenge then is to make
it easy to map the abstracted computation of the program onto actual architectures.  At
a high level, mapping a Legion program entails making two kinds of decisions:

  1. For each task: select a processor on which to run the task.
  2. For each logical region a task needs: select a memory in which to create
     a physical instance of the logical region for the task to use.

To facilitate this process Legion introduces a novel runtime 'mapping' interface.  One of the
NON-goals of the Legion project was to design a programming system that was magically capable
of making intelligent mapping decisions.  Instead the mapping interface provides a declarative
mechanism for the programmer to communicate mapping decisions to the runtime system
without having to actually write any code to perform the mapping (e.g. actually writing
the code to perform a copy or synchronization).  Furthermore, by making the mapping interface
dynamic, it allows the programmer to make mapping decisions based on information that
may only be available at runtime.  This includes decisions based on:

  * Program data: some computations are dependent on data (e.g. is our irregular graph
    sparse or dense in the number of edges).
  * System data: which processors or nodes are currently up or down, or which are running
    fast or slow to conserve power.
  * Execution data: profiling data that is fed back to the mapper about how a certain
    mapping performed previously.  Alternatively which processors are currently over-
    or under- loaded.

All of this information is made available to the mapper via various mapper calls, some
of which query the mapping interface while others simply are communicating information
to the mapper.

One very important property of the mapping interface is that no mapping decisions are
capable of impacting the correctness of the program.  Consequently, all mapping decisions
made are only performance decisions.  Programmers can then easily tune a Legion application
by modifying the mapping interface implementation without needing to be concerned
with how their decisions impact correctness.  Ultimately, this makes it possible in Legion
to explore whole spaces of mapping choices (which tasks run on CPUs or GPUs, or where data
gets placed in the memory hierarchy) simply by enumerating all the possible mapping
decisions and trying them.

To make it easy to get a working program, Legion provides a default mapper implementation
that uses heuristics to make mapping decisions.  In general these decision are good, but
they are certain to be sub-optimal across all applications and architectures.  All calls
in the mapping interface are C++ virtual functions that can be overridden, so programmers
can extend the default mapper and only override the mapping calls that are impacting performance.
Alternatively a program can implement the mapping interface entirely from scratch.

For more details on the Legion programming model and its current implementation
we refer to you to our Supercomputing paper.

http://theory.stanford.edu/~aiken/publications/papers/sc12.pdf

## Contents

This repository includes the following contents:

  * `tutorial`: Source code for the [tutorials](http://legion.stanford.edu/tutorial/).
  * `examples`: Larger examples for advanced programming techniques.
  * `apps`: Several complete Legion applications.
  * `language`: The [Regent programming language](http://regent-lang.org/) compiler and examples.
  * `runtime`: The core runtime components:
      * `legion`: The Legion runtime itself (see `legion.h`).
      * `realm`: The Realm low-level runtime (see `realm.h`).
      * `mappers`: Several mappers, including the default mapper (see `default_mapper.h`).
  * `tools`: Miscellaneous tools:
      * `legion_spy.py`: A [visualization tool](http://legion.stanford.edu/debugging/#legion-spy) for task dependencies.
      * `legion_prof.py`: A task-level [profiler](http://legion.stanford.edu/profiling/#legion-prof).

## Dependencies

To get started with Legion, you'll need:

  * Linux, macOS, or another Unix
  * A C++ 11 (or newer) compiler (GCC, Clang, Intel, or PGI) and GNU Make
  * *Optional*: CMake 3.16 or newer
  * *Optional*: Python 3.5 or newer (used for profiling/debugging tools)
  * *Optional*: CUDA 10.0 or newer (for NVIDIA GPUs)
  * *Optional*: [GASNet](https://gasnet.lbl.gov/) (for networking, see
     [installation instructions](http://legion.stanford.edu/gasnet/))
  * *Optional*: LLVM 7-14 (for dynamic code generation)
  * *Optional*: HDF5 (for file I/O)

## Installing

Legion is currently compiled with each application. To try a Legion
application, just call `make` in the directory in question. The
`LG_RT_DIR` variable is used to locate the Legion `runtime`
directory. For example:

```bash
git clone https://github.com/StanfordLegion/legion.git
export LG_RT_DIR="$PWD/legion/runtime"
cd legion/examples/circuit
make
./circuit
```

## Makefile Variables

The Legion Makefile includes several variables which influence the
build. These may either be set in the environment (e.g. `DEBUG=0
make`) or at the top of each application's Makefile.

  * `DEBUG=<0,1>`: controls optimization level and enables various
    dynamic checks which are too expensive for release builds.
  * `OUTPUT_LEVEL=<level_name>`: controls the compile-time [logging
    level](http://legion.stanford.edu/debugging/#logging-infrastructure).
  * `USE_CUDA=<0,1>`: enables CUDA support.
  * `USE_GASNET=<0,1>`: enables GASNet support (see [installation instructions](http://legion.stanford.edu/gasnet/)).
  * `USE_LLVM=<0,1>`: enables LLVM support.
  * `USE_HDF=<0,1>`: enables HDF5 support.

## Build Flags

In addition to Makefile variables, compilation is influenced by a
number of build flags. These flags may be added to variables in the
environment (or again set inside the Makefile).

  * `USE_SPY=1`: enables [Legion Spy](http://legion.stanford.edu/debugging/#legion-spy).
  * `PRIVILEGE_CHECKS=1`: enables [extra privilege checks](http://legion.stanford.edu/debugging/#privilege-checks).
  * `BOUNDS_CHECKS=1`: enables [dynamic bounds checks](http://legion.stanford.edu/debugging/#bounds-checks).

## Command-Line Flags

Legion and Realm accept command-line arguments for various runtime
parameters. Below are some of the more commonly used flags:

  * `-level <category>=<int>`:
    sets [logging level](http://legion.stanford.edu/debugging/#logging-infrastructure) for `category`
  * `-logfile <filename>`:
    directs [logging output](http://legion.stanford.edu/debugging/#logging-infrastructure) to `filename`
  * `-ll:cpu <int>`: CPU processors to create per process
  * `-ll:gpu <int>`: GPU processors to create per process
  * `-ll:util <int>`: utility processors to create per process
  * `-ll:csize <int>`: size of CPU DRAM memory per process (in MB)
  * `-ll:gsize <int>`: size of GASNET global memory available per process (in MB)
  * `-ll:rsize <int>`: size of GASNET registered RDMA memory available per process (in MB)
  * `-ll:fsize <int>`: size of framebuffer memory for each GPU (in MB)
  * `-ll:zsize <int>`: size of zero-copy memory for each GPU (in MB)
  * `-lg:window <int>`: maximum number of tasks that can be created in a parent task window
  * `-lg:sched <int>`: minimum number of tasks to try to schedule for each invocation of the scheduler

The default mapper also has several flags for controlling the default mapping.
See `default_mapper.cc` for more details.

## Developing Programs

To start a new Legion application, make a new directory and copy
`apps/Makefile.template` into your directory under the name
`Makefile`. Fill in the appropriate fields at the top of the Makefile
with the filenames needed for your application.

Most Legion APIs are described in `legion.h`; a smaller number are
described in the various header files in the `runtime/realm`
directory. The default mapper is available in `default_mapper.h`.

## Debugging

Legion has a number of tools to aid in debugging programs.

### Extended Correctness Checks

Compile with `DEBUG=1 PRIVILEGE_CHECKS=1 BOUNDS_CHECKS=1"
make` and rerun the application. This enables dynamic checks for
privilege and out-of-bounds errors in the application. (These checks
are not enabled by default because they are relatively expensive.) If
the application runs without terminating with an error, then continue
on to Legion Spy.

### Legion Spy

Legion provides a task-level visualization tool called Legion
Spy. This captures the logical and physical dependence graphs. These
may help, for example, as a sanity check to ensure that the correct
sequence of tasks is being launched (and the tasks have the correct
dependencies). Legion Spy also has a self-checking mode which can
validate the correctness of the runtime's logical and physical
dependence algorithms.

To capture a trace, invoke the application with `-lg:spy -logfile
spy_%.log`. (No special compile-time flags are required.) This will
produce a log file per node. Call the post-processing script to render
PDF files of the dependence graphs:

```bash
./app -lg:spy -logfile spy_%.log
$LG_RT_DIR/../tools/legion_spy.py -dez spy_*.log
```

To run Legion Spy's self-checking mode, Legion must be built with the
flag `USE_SPY=1`. Following this, the application can be run again,
and the script used to validate (or render) the trace.

```bash
DEBUG=1 USE_SPY=1 make
./app -lg:spy -logfile spy_%.log
$LG_RT_DIR/../tools/legion_spy.py -lpa spy_*.log
$LG_RT_DIR/../tools/legion_spy.py -dez spy_*.log
```

## Profiling

Legion contains a task-level profiler. No special compile-time flags
are required. However, it is recommended to build with `DEBUG=0 make`
to avoid any undesired performance issues.

To profile an application, run with `-lg:prof <N>` where `N` is the
number of nodes to be profiled. (`N` can be less than the total number
of nodes---this profiles a subset of the nodes.) Use the
`-lg:prof_logfile <logfile>` flag to save the output from each node to
a separate file. The argument to the `-lg:prof_logfile` flag follows
the same format as for `-logfile`, except that a `%` (to be replaced
by the node number) is mandatory. Finally, pass the resulting log
files to `legion_prof.py`.

```bash
DEBUG=0 make
./app -lg:prof <N> -lg:prof_logfile prof_%.gz
$LG_RT_DIR/../tools/legion_prof.py prof_*.gz
```

This will generate a subdirectory called `legion_prof` under the
current directory, including a file named `index.html`. Open this file
in a browser.

## Other Features

- Inorder Execution: Users can force the high-level runtime to execute
all tasks in program order by passing `-lg:inorder` flag on the
command-line.

- Dynamic Independence Tests: Users can request the high-level runtime
perform dynamic independence tests between regions and partitions by
passing `-lg:dynamic` flag on the command-line.

repository: rupanshusoi/legion

branch_name: refs/heads/stable

repo_name: rupanshusoi/legion


text:
# What is this?

This script can be used to generate and populate Cross_From and Cross_To fields in a road centerlines file. It will read in the Full_Street field of the road centerlines, and identify the cross streets at each intersection. Once the cross streets have been identified, their attributes (names) will be populated into the Cross_From and Cross_To fields which are generated by the script. This script will work in ArcGIS 10.2 and 10.3. It is untested at previous versions.

This is an updated version, in C#, of the [Populate Cross Street Names VBA script from ArcScripts](http://arcscripts.esri.com/details.asp?dbid=13213).

# What is required to run this script?

* ArcObjects
* ArcGIS Desktop
* Familiarity with ArcGIS Desktop Addins for .NET
* Three fields:

Cross_From - empty field - Text Field

Cross_To - empty field - Text Field

Full_Stree - Field populated with full street name. (N. Michigan Street)

# Sample Syntax

None.  This was originally designed as an Addin.  Merely append this to one of your addins to create a button to use within ArcMap.

# Use Case

Populates two text fields in a street line feature class based on intersecting streets at the ends of each line.

repository: Esri/developer-support

gha_language: C#

repo_name: Esri/developer-support


text:
# Public API specification

The URLs indicated in the headers of each section are relative to the endpoint URL advertised in the Keystone
catalog under the service type `resources`.

Where permission requirements are indicated, they refer to the default policy. Limes operators can configure their
policy differently, so that certain requests may require other roles or token scopes.

## Request headers

### X-Auth-Token

As with all OpenStack services, this header must contain a Keystone token.

### X-Limes-Cluster-Id

Each Limes API is bound to a certain OpenStack cluster, usually the one where it is configured in the service catalog.
To make a request concerning a domain or project in a different cluster, the `X-Limes-Cluster-Id` header must be given.
Using this header requires special permission (usually a cloud-admin token).

## GET /v1/domains/:domain\_id/projects
## GET /v1/domains/:domain\_id/projects/:project\_id

Query data for projects in a domain. `:project_id` is optional for domain admins. With domain admin token, shows
projects in that token's domain. With project member permission, shows that token's project only. Arguments:

* `service`: Limit query to resources in this service (e.g. `?service=compute`). May be given multiple times.
* `area`: Limit query to resources in services in this area. May be given multiple times.
* `resource`: When combined, with `?service=`, limit query to that resource
  (e.g. `?service=compute&resource=instances`). May be given multiple times.
* `detail`: If given, list subresources for resources that support it. (See subheading below for details.)

Returns 200 (OK) on success. Result is a JSON document like:

```json
{
  "projects": [
    {
      "id": "8ad3bf54-2401-435e-88ad-e80fbf984c19",
      "name": "example-project",
      "parent_id": "e4864dd1-1929-4b41-bb69-e5a724f20fa2",
      "services": [
        {
          "type": "compute",
          "area": "compute",
          "resources": [
            {
              "name": "instances",
              "quota": 5,
              "usage": 1
            },
            {
              "name": "cores",
              "quota": 20,
              "usage": 2,
              "backend_quota": 50
            },
            {
              "name": "ram",
              "unit": "MiB",
              "quota": 10240,
              "usage": 2048
            }
          ],
          "scraped_at":<PHONE_NUMBER>
        },
        {
          "type": "object-store",
          "area": "storage",
          "resources": [
            {
              "name": "capacity",
              "unit": "B",
              "quota":<PHONE_NUMBER>,
              "usage": 104857600
            }
          ],
          "scraped_at":<PHONE_NUMBER>
        },
        ...
      ]
    },
    ...
  ]
}
```

If `:project_id` was given, the outer key is `project` and its value is the object without the array surrounding it.

On the project level, the `id`, `name` and `parent_id` from Keystone are shown. (The parent ID refers to the parent
project if there is one, otherwise it is identical to the domain ID.)

Quota/usage data for the project is ordered into `services`, then into `resources`. In the example above, services
include `compute` and `object_storage`, and the `compute` service has three resources, `instances`, `cores` and `ram`.
The service's `type` attribute will be identical to the same field in the Keystone service catalog. Through the `area`
attribute, services can be grouped into areas like `network` or `storage` for presentational purposes.

The data for each resource must include `quota` and `usage`. If the resource is not counted, but measured in a certain
unit, it will be given as `unit`. Clients should be prepared to handle at least the following values for `unit`:

    B     - bytes
    KiB   - kibibytes = 2^10 bytes
    MiB   - mebibytes = 2^20 bytes
    GiB   - gibibytes = 2^30 bytes
    TiB   - tebibytes = 2^40 bytes
    PiB   - pebibytes = 2^50 bytes
    EiB   - exbibytes = 2^60 bytes

Besides `unit`, there may be another informational field called `category`. If present, UIs can use the string value in
this field to divide resources from the same service into logical groups for presentational purposes. For example, the
service type `network` advertises resources with the category strings `networking` and `loadbalancing`, since these
topics are cleanly separable from each other.

Limes tracks quotas in its local database, and expects that the quota values in the backing services may only be
manipulated by the Limes service user, but not by the project's members or admins. If, nonetheless, Limes finds the
backing service to use a different quota value than what Limes expected, it will be shown in the `backend_quota` key, as
shown in the example above for the `compute/cores` resource. If a `backend_quota` value exists, a Limes client should
display a warning message to the user.

The `scraped_at` timestamp for each service denotes when Limes last checked the quota and usage values in the backing
service. The value is a standard UNIX timestamp (seconds since `1970-00-00T00:00:00Z`).

Valid values for quotas include all non-negative numbers. Backend quotas can also have the special value `-1` which
indicates an infinite or disabled quota.

TODO: Might need to add ordering and pagination to this at some point.

### Subresources

If the `?detail` query parameter is given (no value is required), countable resources may be further broken down into
*subresources*, i.e. entities of this countable resource with their own set of attributes. Intended usecases for
subresource include billing services using data collected by Limes to create itemized bills, or to bill resources
depending on their attributes. (For example, a floating IP in an external network may be more expensive than one from an
internal network.)

Subresources will only be displayed for supported resources, and only if subresource scraping has been enabled for that
resource in Limes' configuration. If enabled, the resource will have a `subresources` key containing an array of
objects. For example, extending the example from above, the `projects[0].services[0].resources[0]` object might look
like this:

```json
{
  "name": "instances",
  "quota": 5,
  "usage": 1,
  "subresources": [
    { "id": "ad87bb8a-5864-4905-b099-40b9f2b49bf9", "name": "testvm", "cores": 2, "ram": { "value": 2048, "unit": "MiB" } }
  ]
}
```

The fields in the subresource objects are specific to the resource type, and are not mandated by this specification.
Please refer to the [documentation for the quota plugin that generates it](../operators/config.md) for details.

## GET /v1/domains
## GET /v1/domains/:domain\_id

Query data for domains. `:domain_id` is optional for cloud admins. With cloud admin token, shows all domains. With
domain admin token, shows that token's domain only. Arguments:

* `service`: Limit query to resources in this service. May be given multiple times.
* `area`: Limit query to resources in services in this area. May be given multiple times.
* `resource`: When combined, with `?service=`, limit query to that resource.

Returns 200 (OK) on success. Result is a JSON document like:

```json
{
  "domains": [
    {
      "id": "d5fbe312-1f48-42ef-a36e-484659784aa0",
      "name": "example-domain",
      "services": [
        {
          "type": "compute",
          "resources": [
            {
              "name": "instances",
              "quota": 20,
              "projects_quota": 5,
              "usage": 1
            },
            {
              "name": "cores",
              "quota": 100,
              "projects_quota": 20,
              "usage": 2,
              "backend_quota": 50
            },
            {
              "name": "ram",
              "unit": "MiB",
              "quota": 204800,
              "projects_quota": 10240,
              "usage": 2048
            }
          ],
          "max_scraped_at":<PHONE_NUMBER>,
          "min_scraped_at":<PHONE_NUMBER>
        },
        {
          "type": "object-store",
          "resources": [
            {
              "name": "capacity",
              "unit": "B",
              "quota":<PHONE_NUMBER>00,
              "projects_quota":<PHONE_NUMBER>,
              "usage": 104857600
            }
          ],
          "max_scraped_at":<PHONE_NUMBER>,
          "min_scraped_at":<PHONE_NUMBER>
        }
        ...
      ]
    },
    ...
  ]
}
```

If `:domain_id` was given, the outer key is `domain` and its value is the object without the array surrounding it.

Looks a lot like the project data, but each resource has two quota values: `quota` is the quota assigned by the
cloud-admin to the domain, and `projects_quota` is the sum of all quotas assigned to projects in that domain by the
domain-admin. If the backing service has a different idea of the quota values than Limes does, then `backend_quota`
shows the sum of all project quotas as seen by the backing service. If any of the aggregated backend quotas is
`-1`, the `backend_quota` field will contain the sum of the *finite* quota values only, and an additional key
`infinite_backend_quota` will be added. For example:

```js
// resources before aggregation
{ "quota": 10, "usage": 0 }
{ "quota":  5, "usage": 12, "backend_quota": -1 }
{ "quota":  5, "usage": 5 }

// resources after aggregation
{ "quota": 20, "usage": 17, "backend_quota": 15, "infinite_backend_quota": true }
```

In contrast to project data, `scraped_at` is replaced by `min_scraped_at` and `max_scraped_at`, which aggregate over the
`scraped_at` timestamps of all project data for that service and domain.

**TODO:** Open question: Instead of aggregating backend quotas, maybe just include
a `warnings` field that counts projects with `quota != backend_quota`?

## GET /v1/clusters
## GET /v1/clusters/:cluster\_id
## GET /v1/clusters/current

Query data for clusters. Requires a cloud-admin token. Arguments:

* `service`: Limit query to resources in this service. May be given multiple times.
* `area`: Limit query to resources in services in this area. May be given multiple times.
* `resource`: When combined, with `?service=`, limit query to that resource.
* `local`: When given, quota and usage for shared resources is not aggregated across clusters (see below).
* `detail`: If given, list subcapacities for resources that support it. (See subheading below for details.)

Returns 200 (OK) on success. Result is a JSON document like:

```json
{
  "current_cluster": "example-cluster-2",
  "clusters": [
    {
      "id": "example-cluster",
      "services": [
        {
          "type": "compute",
          "resources": [
            {
              "name": "instances",
              "domains_quota": 20,
              "usage": 1
            },
            {
              "name": "cores",
              "capacity": 1000,
              "domains_quota": 100,
              "usage": 2
            },
            {
              "name": "ram",
              "unit": "MiB",
              "capacity": 1048576,
              "domains_quota": 204800,
              "usage": 2048
            }
          ],
          "max_scraped_at":<PHONE_NUMBER>,
          "min_scraped_at":<PHONE_NUMBER>
        },
        {
          "type": "object-store",
          "shared": true,
          "resources": [
            {
              "name": "capacity",
              "unit": "B",
              "capacity":<PHONE_NUMBER>0000,
              "comment": "looked it up in `df`",
              "domains_quota":<PHONE_NUMBER>00,
              "usage": 104857600
            }
          ],
          "max_scraped_at":<PHONE_NUMBER>,
          "min_scraped_at":<PHONE_NUMBER>
        },
        ...
      ],
      "max_scraped_at":<PHONE_NUMBER>,
      "min_scraped_at":<PHONE_NUMBER>
    },
    ...
  ]
}
```

The `current_cluster` key is only present if no `:cluster_id` was given.

If `:cluster_id` was given, the outer key is `cluster` and its value is the object without the array surrounding it. As
a special case, a cluster ID of `current` will be substituted by the current cluster (i.e. the one for which domains and
projects can be inspected on this endpoint).

Clusters do not have a quota, but resources may be constrained by a `capacity` value. The `domains_quota` field behaves
just like the `projects_quota` key on domain level. Discrepancies between project quotas in Limes and in backing
services will not be shown on this level, so there is no `backend_quota` key.

The `capacity` key is will only be supplied when a capacity is known. Capacity values can be maintained by cluster
administrators, in which case a `comment` string will be present (such as for `object_storage/capacity` in the example
output above). The capacity is only informational: Cloud admins can choose to exceed the reported capacity when
allocating quota to domains.

The `min_scraped_at` and `max_scraped_at` timestamps on the service level refer to the usage values (aggregated over all
projects just like for `GET /domains`).

The `min_scraped_at` and `max_scraped_at` timestamps on the cluster level refer to the cluster capacity values. Capacity
plugins (and thus, capacity scraping events) are not bound to a single service, which is why the scraping timestamps
cannot be shown on the service level here.

For resources belonging to a cluster-local service (the default), the reported quota and usage is aggregated only over
domains in this cluster. For resources belonging to a shared service, the reported quota and usage is aggregated over
all domains in all clusters (and will thus be the same for every cluster listed), unless the query parameter `local` is
given. Shared services are indicated by the `shared` key on the service level (which defaults to `false` if not
specified).

### Subcapacities

If the `?detail` query parameter is given (no value is required), capacity for a resource may be further broken down into
*subcapacities*, i.e. a list of individual capacities with individual properties.

Subcapacities will only be displayed for supported resources, and only if subcapacity scraping has been enabled for that
resource in Limes' configuration. If enabled, the resource will have a `subresources` key containing an array of
objects. For example, extending the example from above, the `projects[0].services[0].resources[1]` object might look
like this:

```json
{
  "name": "cores",
  "capacity": 1000,
  "domains_quota": 100,
  "usage": 2,
  "subcapacities": [
    { "hypervisor": "cluster-1", "cores": 200 },
    { "hypervisor": "cluster-2", "cores": 800 }
  ]
}
```

The fields in the subcapacity objects are specific to the resource type, and are not mandated by this specification.
Please refer to the [documentation for the corresponding capacity plugin](../operators/config.md) for details.

## POST /v1/domains/discover

Requires a cloud-admin token. Queries Keystone in order to discover newly-created domains that Limes does not yet know
about.

When no new domains were found, returns 204 (No Content). Otherwise, returns 202 (Accepted) and a JSON document listing
the newly discovered domains:

```json
{
  "new_domains": [
    { "id": "94cfaed4-3062-47d2-9299-ef599d5ffbfb" },
    { "id": "b66dcb34-ea53-4872-b99b-123ae9c581b4" },
    ...
  ]
}
```

When the call returns, quota/usage data for these domains will not yet be available (thus return code 202).

*Rationale:* When a cloud administrator creates a new domain, he might want to assign quota to that domain immediately
after that, but he can only do so after Limes has discovered the new domain. Limes will do so automatically after some
time through scheduled auto-discovery, but this call can be used to reduce the waiting time.

## POST /v1/domains/:domain\_id/projects/discover

Requires a domain-admin token for the specified domain. Queries Keystone in order to discover newly-created projects in
this domain that Limes does not yet know about. This works exactly like `POST /domains/discover`, except that the JSON
document will list `new_projects` instead of `new_domains`.

*Rationale:* Same as for domain discovery: The domain admin might want to assign quotas immediately after creating a new
project.

## POST /v1/domains/:domain\_id/projects/:project\_id/sync

Requires a project-admin token for the specified project. Schedules a sync job that pulls quota and usage data for this
project from the backing services into Limes' local database. When the job was scheduled successfully, returns 202
(Accepted).

If the project does not exist in Limes' database yet, query Keystone to see if this project was just created. If so, create the project in Limes' database before returning 202 (Accepted).

*Rationale:* When a project administrator wants to adjust her project's quotas, she might discover that the usage data
shown by Limes is out-of-date. She can then use this call to refresh the usage data in order to make a more informed
decision about how to adjust her quotas.

## PUT /v1/domains/:domain\_id

Set quotas for the given domain. Requires a cloud-admin token, and a request body that is a JSON document like:

```json
{
  "domain": {
    "services": [
      {
        "type": "compute",
        "resources": [
          {
            "name": "instances",
            "quota": 30
          },
          {
            "name": "cores",
            "quota": 150
          }
        ]
      },
      {
        "type": "object-store",
        "resources": [
          {
            "name": "capacity",
            "quota": 60000,
            "unit": "MiB"
          }
        ]
      }
    ]
  }
}
```

For resources that are measured rather than counted, the values are interpreted with the same unit that is mentioned for
this resource in `GET /domains/:domain_id`. However, a `unit` string may be given to override this default. All
resources that are not mentioned in the request body remain unchanged. This operation will not affect any project
quotas in this domain.

Returns 200 (OK) on success, with a response body identical to `GET` on the same URL, containing the updated quota
values.

## PUT /v1/domains/:domain\_id/projects/:project\_id

Set quotas for the given project. Requires a domain-admin token for the specified domain. Other than that, the call
works in the same way as `PUT /domains/:domain_id`.

## PUT /v1/clusters/:cluster_id

## PUT /v1/clusters/current

Set capacity values for the given cluster. Requires a cloud-admin token, and a request body that is a JSON document
like:

```json
{
  "cluster": {
    "services": [
      {
        "type": "compute",
        "resources": [
          {
            "name": "instances",
            "capacity": 30,
            "comment": "guesstimate"
          },
          {
            "name": "cores",
            "capacity": 150,
            "comment": "counted them by hand"
          }
        ]
      },
      {
        "type": "object-store",
        "resources": [
          {
            "name": "capacity",
            "capacity": 0,
            "comment": "data center on fire"
          }
        ]
      }
    ]
  }
}
```

For resources that are measured rather than counted, the values are interpreted with the same unit that is mentioned for
this resource in `GET /clusters/:cluster_id`. However, a `unit` string may be given to override this default. All
resources that are not mentioned in the request body remain unchanged. This operation will not affect any domain or
project quotas.

Capacity values can only be set for resources which Limes does not know how to measure automatically. A `comment` is
always required, and should ideally contain a description of how the capacity value was derived. An existing
capacity value can be deleted by setting it to `-1`, in which case no `comment` is required.

Returns 200 (OK) on success, with a response body identical to `GET` on the same URL, containing the updated capacity
values.

repository: BugRoger/limes

repo_name: BugRoger/limes


text:
# libnabla

[![Build Status](https://travis-ci.com/NablaVM/libnabla.svg?branch=master)](https://travis-ci.com/NablaVM/libnabla)
![](https://img.shields.io/badge/License-MIT-blueviolet)
![](https://img.shields.io/badge/Built%20with-C%2B%2B-red)

The development library for the NablaVM

### Requires :

    cpputest

### Build Instructions

    mkdir build && cd build
    cmake ../lib
    make -j4
    sudo make install
    cd -

### Uninstall

    cd build
    sudo make uninstall

repository: NablaVM/libnabla

repo_name: NablaVM/libnabla


text:
# Windows Server 2016 Audit

based on
* _Windows Server 2016 Security Technical Implementation Guide V1R6 2018-08-26_
* and _CIS Microsoft Windows Server 2016 RTM (Release 1607) Benchmark v1.1.0 - 2018-10-31_

## Overview

The `WindowsServer2016Audit`-Module benchmarks your Windows Server 2016 settings with current hardening standards such as the DISA Security Technical Implementation Guide and the CIS Benchmarks.

## Requirements

Please make sure that following requirements are fulfilled:

* **Windows Server 2016**
* **ATAPHtmlReport Module:** This module is used for the html report generation and is [included](https://github.com/fbprogmbh/Audit-Test-Automation/tree/master/ATAPHtmlReport) in the Audit Test Automation Package. Follow the instructions at the link to install the module.

## Loading the Windows Server 2016 Audit module

1. Download the release zip and export the modules in a location you can easily access with PowerShell
2. Navigate to the location with PowerShell and import the modules with `Import-Module`. For example:
```Powershell
cd .\Desktop\
Import-Module -Name .\Audit-Test-Automation\WindowsServer2016Audit -Verbose
```
3. Generate a report with `Get-WindowsServer2016HtmlReport` For example:
```PowerShell
Get-WindowsServer2016HtmlReport -Path "MyReport.html"
```

## Sample report

You can find a sample report in the [Sample](Sample) folder.

## Remarks

The script runs a while - do not be impatient.

repository: VCKoh/Audit-Test-Automation

repo_name: VCKoh/Audit-Test-Automation


text:
# dumpedlastbuf
Console app for reading from stdin and writing to stdout via a ring buffer with the output of the last data to the dump file if there is a problem when reading or writing.

# Download
git clone https://github.com/sergey-sh/dumpedlastbuf.git

# Compile
cd dumpedlastbuf
make

# Example of use

seq -w 1 1 10000000|./dumpedlastbuf 6016 9998592|wc -c

In this example, 6016 bytes are read from the standard input once and sent to standard output. If reading or writing did not complete 6106 bytes, the last 9998592 is copied to the dump file under the name YYYYMMDDHHmmSS.dump in the current directory.

repository: sergey-sh/dumpedlastbuf

repo_name: sergey-sh/dumpedlastbuf


text:
# About this project

📖 Read the [The System Design Checklist](https://evelyne24.github.io/system-design-checklist/).

## What this checklist is

This is a checklist of things to think about when designing or re-designing a software system or parts of it.

For example, a specialised, shorter version of this checklist can be used to design:

- an Minimum Viable Product (MVP) for a pre-PMF company
- a microservice for a post-PMF company
- a migration process from a monolith to a microservice architecture
- a logging and monitoring system for external auditing
- a frontend component
- a new API endpoint etc.

## What this checklist is not

This is not a tutorial on software system design. However, as a refresher, I added a few notes about _**why**_ certain questions are important and some opinionated suggestions. Feel free to skip over them.

## How I came up with the checklist

 I've successfully used checklists my entire life, as a software engineer, during my time as a CTO of an early-stage fintech app, where I designed software for high-street banks and when I prepared for the [AWS Solution Architect](https://aws.amazon.com/certification/certified-solutions-architect-associate/) exam. I created a mental checklist to:

- extract the system requirements from the question
- determine the desired system properties
- break down the system layers
- consider trade-offs at each layer

This is how I was able answer 60+ scenario-based questions in 120 minutes and pass the exam 🙌.

## Why I made the checklist public

We are bombarded by new information every day. There are many books and articles on software system design. Technologies, frameworks, languages, practices change at huge speed.

However, most of them lack a practical format, to apply the knowledge immediately. Also, our brains can't cope well with so many long-form texts on a daily basis.

I noticed a move towards checklists and flowcharts in the developer community. Therefore, this repository is the first step towards a practical tool. I want to help not only first-time CTOs, but any software team before a routine design task.

I hope the checklist accomplishes three goals:

1. Helps them **discover unknown unknowns** by sparking curiosity and reflection ahead of the design task.
2. Inspires them to **use it in Pre-Mortems**, to better assess high-impact, high-risk systems, and **in Post-Mortems**, to update it with learnings discovered the hard way.
3. Used and refined frequently, it **builds good habits** leading to high quality work.

“Checklists […] remind us of the minimum necessary steps and make them explicit. They not only offer the possibility of verification but also instill a kind of discipline of higher performance.” — Atul Gawande, The Checklist Manifesto

## How to contribute to the checklist

If you like the checklist, let's make it more useful together! 💪

Mistakes are human nature. Because technology advances so quickly, what was good-enough yesterday may not be tomorrow. Nobody can know everything at all times.

You're very welcome to contribute to fix mistakes, and refine the list of questions and options by submitting a Pull Request.

I'm running some tests with real teams from a few companies to benchmark if the usage of a checklist results in:

> - shorter `commit → review → deploy` cycles
> - improved code quality
> - increased number of issued discovered ahead
> - fewer severe incidents
> - better knowledge loops in and between teams

If you want to try it, email me at<EMAIL_ADDRESS>Feel free to leave a comment with suggestions to make it more specific or shorter for certain cases, like the ones I mentioned in the first paragraph.

### How to run Jekyll locally

1. Install [Docker](https://www.docker.com/) on your machine
2. Run Jekyll: `docker-compose up`
3. The browser should livereload at `http://localhost:4000`

## 👩🏻💻 About me

- [LinkedIn](https://www.linkedin.com/in/evelinavrabie/)
- [Medium](https://medium.com/jump-start)

repository: konkrr/system-design-checklist

branch_name: refs/heads/main

repo_name: konkrr/system-design-checklist


text:
# UI.Ace directive [![Build Status](https://travis-ci.org/angular-ui/ui-ace.svg)](https://travis-ci.org/angular-ui/ui-ace)

This directive allows you to add [ACE](http://ajaxorg.github.io/ace/) editor elements.

## Requirements

- AngularJS
- [Ace 1.x](https://github.com/ajaxorg/ace-builds/)

## Usage

You can get it from [Bower](http://bower.io/)

```sh
bower install angular-ui-ace\#bower
```

This will copy the UI.Ace files into a `bower_components` folder, along with its dependencies. Load the script files in your application:

```html
<script type="text/javascript" src="bower_components/ace-builds/src-min-noconflict/ace.js"></script>
<script type="text/javascript" src="bower_components/angular/angular.js"></script>
<script type="text/javascript" src="bower_components/angular-ui-ace/ui-ace.js"></script>
```

Add the UI.Ace module as a dependency to your application module:

```javascript
var myAppModule = angular.module('MyApp', ['ui.ace']);
```

Finally, add the directive to your html:

```html
<div ui-ace></div>
```

To see something it's better to add some CSS, like

```css
.ace_editor { height: 200px; }
```

## Options

Ace doesn't provide a one gate access to all the options the jquery way.
Each option is configured with the function of a specific instance.
See the [api doc](http://ajaxorg.github.io/ace/#nav=api) for more.

Although, _ui-ace_ automatically handles some handy options :
 + _showGutter_ : to show the gutter or not.
 + _useWrapMode_ : to set whether or not line wrapping is enabled.
 + _theme_ : to set the theme to use.
 + _mode_ : to set the mode to use.
 + _onLoad_ : callback when the editor has finished loading (see [below](#ace-instance-direct-access)).
 + _onChange_ : callback when the editor content is changed ().
 + _onBlur_ : callback when the editor is blurred ().
 + _firstLineNumber_ : to set the firstLineNumber (default: 1)

```html
<div ui-ace="{
  useWrapMode : true,
  showGutter: false,
  theme:'twilight',
  mode: 'xml',
  firstLineNumber: 5,
  onLoad: aceLoaded,
  onChange: aceChanged
}"></div>
```

You'll want to define the `onLoad` and the `onChange` callback on your scope:

```javascript
myAppModule.controller('MyController', [ '$scope', function($scope) {

  $scope.aceLoaded = function(_editor) {
    // Options
    _editor.setReadOnly(true);
  };

  $scope.aceChanged = function(e) {
    //
  };

}]);
```

To handle other options you'll have to use a direct access to the Ace created instance (see [below](#ace-instance-direct-access)).

## Advanced Options

You can specify advanced options and even `require` options in the directive, as well. For this example, you
will have to include the `ext-language_tools.js` file from the ace source code.

This will copy the UI.Ace files into a `bower_components` folder, along with its dependencies. Load the script files in your application:

```html
<script type="text/javascript" src="bower_components/ace-builds/src-min-noconflict/ext-language_tools.js"></script>
```

```html
<div ui-ace="{
  require: ['ace/ext/language_tools'],
  advanced: {
      enableSnippets: true,
      enableBasicAutocompletion: true,
      enableLiveAutocompletion: true
  }
}"></div>
```

To include options applicable to the ACE renderer, you can use the `rendererOptions` key:

```html
<div ui-ace="{
  rendererOptions: {
      maxLinks: Infinity
  }
}"></div>
```

## Support for concatenated bundles

Trying to use ace with concatenated javascript files usually fails because it changes the physical location of the `workerPath`. If you
need to work with bundled or minified versions of ace, you can specify the original location of the `workerPath` on disk (_not the bundled file_).

This should be the folder on disk where `ace.js` resides.

```html
<div ui-ace="{
  workerPath: '/path/to/ace/folder'
}"></div>
```

### Working with ng-model

The ui-ace directive plays nicely with ng-model.

The ng-model will be watched for to set the Ace EditSession value (by [setValue](http://ajaxorg.github.io/ace/#nav=api&api=edit_session)).

_The ui-ace directive stores and expects the model value to be a standard javascript String._

### Can be read only

Simple demo
```html
<div ui-ace readonly></div>
or
Check me to make Ace readonly: <input type="checkbox" ng-model="checked" ><br/>
<div ui-ace ng-readonly="checked"></div>
```

### Ace instance direct access

For more interaction with the Ace instance in the directive, we provide a direct access to it.
Using

```html
<div ui-ace="{ onLoad : aceLoaded }" ></div>
```

the `$scope.aceLoaded` function will be called with the [Ace Editor instance](http://ajaxorg.github.io/ace/#nav=api&api=editor) as first argument

```javascript
myAppModule.controller('MyController', [ '$scope', function($scope) {

  $scope.aceLoaded = function(_editor){
    // Editor part
    var _session = _editor.getSession();
    var _renderer = _editor.renderer;

    // Options
    _editor.setReadOnly(true);
    _session.setUndoManager(new ace.UndoManager());
    _renderer.setShowGutter(false);

    // Events
    _editor.on("changeSession", function(){ ... });
    _session.on("change", function(){ ... });
  };

}]);
```

## Testing

We use Karma and jshint to ensure the quality of the code.  The easiest way to run these checks is to use grunt:

```sh
npm install -g grunt-cli
npm install && bower install
grunt
```

The karma task will try to open Firefox and Chrome as browser in which to run the tests.  Make sure this is available or change the configuration in `test\karma.conf.js`

### Grunt Serve

We have one task to serve them all !

```sh
grunt serve
```

It's equal to run separately:

* `grunt connect:server` : giving you a development server at [http://<IP_ADDRESS>:8000/](http://<IP_ADDRESS>:8000/).

* `grunt karma:server` : giving you a Karma server to run tests (at [http://localhost:9876/](http://localhost:9876/) by default). You can force a test on this server with `grunt karma:unit:run`.

* `grunt watch` : will automatically test your code and build your demo.  You can demo generation with `grunt build:gh-pages`.

### Dist

This repo is using the [angular-ui/angular-ui-publisher](https://github.com/angular-ui/angular-ui-publisher).
New tags will automatically trigger a new publication.
To test is locally you can trigger a :

```sh
grunt dist build:bower
```

it will put the final files in the _'dist'_ folder and a sample of the bower tag output in the _'out/built/bower'_ folder.

repository: atomiton/SmartParkingHelloWorld

repo_name: atomiton/SmartParkingHelloWorld


text:
# Python-Download-Google-Drive-Images
Python Download Google Drive Images / Python Bulk Download Google Drive Images

## Requirement

For this tool to work you will need python3. Download the repo.

## 1. Setup
```
pip3 install gdown
```
## 2. Getting started

replace all the urls in the urls.csv

## 3. Run
```
cd Python-Download-Google-Drive-Images-main
python3 script.py
```
## Preview

![Preview](./preview.png)

## Error fixing
if you expierience some errors please keep in mind that the csv, which is used should not include ";" as the row devider. This tool uses ","(comma) as dividing rows. This means if you run in errors just open the urls.csv with a text editor and check if there are ";" or ",". If there are ";" replace all of them with ","(commas). This sould fix the problem.


text:
# Dynamic Toasts

[![License](https://img.shields.io/badge/license-Apache%202-4EB1BA.svg?)](https://www.apache.org/licenses/LICENSE-2.0.html)
[![Build Status](https://travis-ci.org/pranavpandey/dynamic-toasts.svg?branch=master)](https://travis-ci.org/pranavpandey/dynamic-toasts)

A simple library to display themed toasts with icon and text on Android 9+ (Gingerbread or above)
devices.

---

## Table of Contents

1. [Installation](https://github.com/pranavpandey/dynamic-toasts#installation)
2. [Usage](https://github.com/pranavpandey/dynamic-toasts#usage)
    1. [Default toast](https://github.com/pranavpandey/dynamic-toasts#default-toast)
    2. [Default toast with duration](https://github.com/pranavpandey/dynamic-toasts#default-toast-with-duration)
    3. [Default toast with icon](https://github.com/pranavpandey/dynamic-toasts#default-toast-with-icon)
    4. [Default toast with icon and duration](https://github.com/pranavpandey/dynamic-toasts##default-toast-with-icon-and-duration)
    5. [Error toast](https://github.com/pranavpandey/dynamic-toasts#error-toast)
    6. [Error toast with duration](https://github.com/pranavpandey/dynamic-toasts#error-toast-with-duration)
    7. [Success toast](https://github.com/pranavpandey/dynamic-toasts#success-toast)
    8. [Success toast with duration](https://github.com/pranavpandey/dynamic-toasts#success-toast-with-duration)
    9. [Warning toast](https://github.com/pranavpandey/dynamic-toasts#warning-toast)
    10. [Warning toast with duration](https://github.com/pranavpandey/dynamic-toasts#warning-toast-with-duration)
    11. [Custom toast](https://github.com/pranavpandey/dynamic-toasts#custom-toast)
    12. [Custom toast with duration](https://github.com/pranavpandey/dynamic-toasts#custom-toast-with-duration)
    13. [Custom toast with icon](https://github.com/pranavpandey/dynamic-toasts#custom-toast-with-icon)
    14. [Custom toast with icon and duration](https://github.com/pranavpandey/dynamic-toasts#custom-toast-with-icon-and-duration)
    15. [Dependency](https://github.com/pranavpandey/dynamic-toasts#dependency)
3. [License](https://github.com/pranavpandey/dynamic-toasts#license)

---

## Installation

It can be installed by adding the following dependency to your `build.gradle` file:

```groovy
dependencies {
    compile 'com.pranavpandey.android:dynamic-toasts:0.2.0'
}
```

---

## Usage

It has several method to display toasts based on the requirement. Each method returns a `Toast`
object which can be customised further.

Please call `show` method to display the toast.

### Default toast

Simple toast based on the vanilla Android theme for `Toast.LENGTH_SHORT` duration.

```java
DynamicToast.make(context, "Default toast").show();
```

### Default toast with duration

Simple toast based on the vanilla Android theme for supplied duration.

```java
DynamicToast.make(context, "Default toast with duration", duration).show();
```

### Default toast with icon

Simple toast based on the vanilla Android theme with a icon for `Toast.LENGTH_SHORT` duration.

```java
DynamicToast.make(context, "Default toast with icon", drawable).show();
```

### Default toast with icon and duration

Simple toast based on the vanilla Android theme with a icon for supplied duration.

```java
DynamicToast.make(context, "Default toast with icon and duration", drawable, duration).show();
```

### Error toast

Error toast with `#F44336` background for `Toast.LENGTH_SHORT` duration.

```java
DynamicToast.makeError(context, "Error toast").show();
```

### Error toast with duration

Error toast with `#F44336` background for supplied duration.

```java
DynamicToast.makeError(context, "Error toast with duration", duration).show();
```

### Success toast

Success toast with `#4CAF50` background for `Toast.LENGTH_SHORT` duration.

```java
DynamicToast.makeSuccess(context, "Success toast").show();
```

### Success toast with duration

Success toast with `#4CAF50` background for supplied duration.

```java
DynamicToast.makeSuccess(context, "Success toast with duration", duration).show();
```

### Warning toast

Warning toast with `#FFEB3B` background for `Toast.LENGTH_SHORT` duration.

```java
DynamicToast.makeWarning(context, "Warning toast").show();
```

### Warning toast with duration

Warning toast with `#FFEB3B` background for supplied duration.

```java
DynamicToast.makeWarning(context, "Warning toast with duration", duration).show();
```

### Custom toast

Custom toast based on the supplied background and tint color for `Toast.LENGTH_SHORT` duration.

```java
DynamicToast.make(context, "Custom toast", tintColor, backgroundColor).show();
```

### Custom toast with duration

Custom toast based on the supplied background and tint color for supplied duration.

```java
DynamicToast.make(context, "Custom toast with duration", tintColor, backgroundColor, duration).show();
```

### Custom toast with icon

Custom toast based on the supplied icon, background and tint color theme for `Toast.LENGTH_SHORT`
duration.

```java
DynamicToast.make(context, "Custom toast with icon", drawable, tintColor, backgroundColor).show();
```

### Custom toast with icon and duration

Custom toast based on the supplied icon, background and tint color theme for supplied duration.

```java
DynamicToast.make(context, "Custom toast with icon and duration", drawable, tintColor, backgroundColor, duration).show();
```

### Dependency

As it depends on the [Dynamic Utils](https://github.com/pranavpandey/dynamic-utils), its functions
can be used to perform other operations.

---

## License

    Copyright (c) 2017 Pranav Pandey

    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.

repository: creativetrendsapps/dynamic-toasts

repo_name: creativetrendsapps/dynamic-toasts


text:
# latex-mimore: A minimal & modern template for reports

This repository contains a minimal & modern LaTeX template for reports
that have to be written for courses at university. It assumes that the
user is a student who has been given a certain topic.

For the impatient or curious: [this is how the template looks
like](Seminar.pdf).

# Advantages

This template aims to be…
- clean: no LaTeX trickery
- minimal: no unnecessary adjustments and decorations
- modern: typographically pleasing

It is specifically suited for the European education system because it
uses A4 paper size by default.

# How to use

- Clone this repository
- Copy the file `mimore.cls` into your document directory
- Add `\documentclass{mimore}` to your document preamble
- Add all `\newcommand` instructions from the example file `Seminar.tex`
  to your document preamble and adjust the example values
- Write a nice report in LaTeX

# Example

The repository comes with an example file called `Seminar.tex`. Please
take a look at this file in order for more detailed instructions about
how to use the class.

It is recommended to use `latexmk` to build your LaTeX documents. Your
distribution might already have this command. If so, you can use

    latexmk

in the main directory of this repository in order to build the example
file.

# License

The template uses the MIT license. Please see the file
[`LICENSE.md`](LICENSE.md) in the main directory of the repository for
more details.

# Contributing

If you require additional features, find some bugs, or just have some
generic inquiries, please just open an issue in this repository.

repository: magfoto/latex-mimore

repo_name: magfoto/latex-mimore


text:
Pollbooth [![Build Status](https://travis-ci.org/crowdtap/pollbooth.png?branch=master)](https://travis-ci.org/crowdtap/pollbooth)
======

Pollbooth is an easy way to cache data that is automatically refreshed at a regular interval.

Install
-------

```ruby
gem install pollbooth
```
or add the following line to your Gemfile:
```ruby
gem 'pollbooth'
```
and run `bundle install`

Usage
-----

```ruby
  class MemberCache
    include PollBooth

    cache 10.seconds do
      Hash[Member.all.map { |member| [member.id, member.age] }]
    end
  end
```

This will cache the age attribue using the member id as the key. So
`MemberCache.lookup('jon@example.com')` will return the age of the member with
email address<EMAIL_ADDRESS>
The poller will start lazily on the first lookup but you can also start it
manually. This is recommended if populating the cache is expensive and will
compromise the first request. You should do this in the `after_fork` block if
you are using unicorn. Otherwise you can do it in an initializer.

```ruby
  MemberCache.start
```

License
-------
Copyright (C) 2013 Crowdtap

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

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

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

repository: crowdtap/pollbooth

gha_language: Ruby

repo_name: crowdtap/pollbooth