text:
---
title: Recipes
type: products
image: /img/cooking2.jpeg
heading: Enjoy!
description: >
  This is where you can view all the recipes that I have added to the page. Go
  ahead and try them out and add feedback to what you think!
intro:
  blurbs:
    - image: /img/pizza.jpg
      heading: Homemade Pizza
      text: >
        Homemade Pizza is very easy to make.
        First you can either buy dough from the store or you can make your own dough.
        Make sure you get enough dough for the amount of people you are making it
        for. You also want to buy your toppings and sauce for your pizza. The
        first pizza in the picture has pepperoni, cheese and red sauce. The second
        pizza has pesto and cheese. Preheat the oven to 350 degrees. Prep your pizza.
        Add sauce. Add cheese. Add other toppings.
        Once oven gets tp 350 degrees you can put your pizza in.
        Let cook for around 15 minutes (This depends on if you create your own
        dough or you buy one from the store.)
        Enjoy after it looks cooked and crispy.
    - image: /img/wings.jpg
      heading: Wings
      text: >
        Wings are always good for a fun get together or a appetizer!
        First you want to buy chicken from the store. Whether its wings or breasts
        you want to make sure you clean them very well. Next you can buy a seasoning
        or flavor you would like your wings to be. In the picture me and my roommates
        chose buffalo sauce. The sauce was made with franks red hot and butter.
        We Preheated the oven to 425 degrees. Then we cooked the wings without
        the sauce on. Make sure you cook the wings until they are fully done.
        They should cook around 40 minutes. Then take them out and spread the
        sauce or seasonal on them to enjoy.
    - image: /img/Stirfry.jpg
      text: >
        Stir Fry can contain many different things that you enjoy. In the Stir
        Fry above there are a variety of vegetables and rice. You want to start
        with a pan and a little bit of oil on the stove. Then add your rice. Could
        be any type of rice you would like. Then add your vegetables, I added
        edamame, carrots, broccoli, onions, and peas. You cut all the vegetables
        up to a perfect size then continue to mix until vegetables and rice are
        fried. You add any sauce you would like. I believe we added soy sauce and
        sweet and sour.
    - image: /img/mac.jpeg
      text: >
        Mac n cheese. First you want to boil water to cook the noodles. Most
        people use shells or little noodles for mac n cheese. Once water is boiling
        add the noodles until soft. Next I made homemade cheese sauce. First you
        want around 1/4 cup of butter in a pan. Then 1/4
        flour add to the pan. Next you want to slowly mix the flour with the
        butter and add 2 cups of milk. Then you c an add your cheese (whatever kind
        you want to use) and mix until cheese is melted. The mac and cheese I made
        had little pieces of crispy bacon. You can add whatever you would like.
        Mix cheese and noodles together and it will be ready to serve.
    - image: /img/cajun.jpeg
      text: >
        Cajun Shrimp Pasta. First you want to turn on your water for your pasta
        so it can start to boil while you work on the sauce and the shrimp.
        Next for the sauce, you need 1/2 stick of butter, 1 1/4 cup of chicken
        broth, 1 1/4 cup of milk, 1 1/4 cup of whipping cream, and 1/4 flour.
        You can add old bay to your sauce, add as much as you want.
        Add them all together in a pan and stir occasionally. Keep on medium until
        it starts to get thick and bubble. Next, you want to put your shrimp on
        a pan and cook until shrimp turn pink. Once your water is done boiling,
        add you noodles and cook until noodles are soft. Then, drain your noodles,
        and mix the shrimp and sauce together. You can also add broccoli to the
        pasta for another taste.
    - image: /img/salad.jpeg
      text: >
       Macaroni salad. First you want to boil water in a pot for the noodles.
       You want to use small elbow noodles for this type of salad. Wait until
       the water is at a boil to add the noodle to the water. After noodles
       are cooked, drain them.  Celery, peppers, and hard boiled eggs. Next you need to
       add mayonnaise. Mix all the ingredients together then you have yourself
       macaroni salad.
    - image: /img/chicken.jpeg
      text: >
        Barbeque chicken. First you want to clean the chicken before you
        put it on the grill. Next you want to cook it until its not pink inside
        and looks crispy. Next you want to make the Barbeque sauce. You want to
        put a pan on the stove with ketchup and soy sauce. You can decide on the
        amount of each. Next you can add some salt and pepper to the mix as well.
        Next you want to spread it on the chicken and enjoy!
  description: >
    Here is where you can explore all the recipes. All the instructions are down
    under the photo of the meal. Follow along to make your own!
---

repository: munzekm/makingitwmega

repo_name: munzekm/makingitwmega


text:
# WTICKETMASTER

#### README

2016 there was a mega huge leak in Sweden, same day as I found the database (before media had known of it) I decided to create a brute forcing tool
for attacking all these accounts that was leaked, I was surprised, more then 70% of all accounts was working on the new biljett.nu site wich is known
as ticketmaster.com, I created this tool for 3 years ago and decided to share it today for you all who want some swedes logins. Of course many
has changed password when they re-addded their accounts on the new domain.

 Even swedish police accounts still working according to a friend since I have just built this tool but I have never
used it personally, the video preview is from my friend, so as usual!! Don't blame me and don't break the law,

This is probably the best tool online that will bring you thousands of swedish logins, enjoy this tool and have fun.

#### INFO:

Here are few links about the leak:

[Critical ticket site hacked - thousands of logins have leaked](https://www.aftonbladet.se/nyheter/a/8wjdvE/kritiserad-biljettsajt-hackad--tusentals-inlogg-har-lackt)

[Ticket site hacked - login has leaked](https://www.expressen.se/dinapengar/biljettsajt-hackad--inlogg-har-lackt-ut/)

#### Preview:

![Screenshot](.preview/ticketmaster.gif)

#### HOWTO:

#### Since it's against the law to upload leaked accounts I wont upload any dump
#### and you should go find it yourself if you don't already got the leaked db

     git clone https://github.com/wuseman/ticketmaster
     cd ticketmaster; chmod +x ticketmaster
     bash ./ticketmaster <biljett.nu-database>

#### NOTICE

wuseman assumes no responsibility whatsoever for what users use this tool for, each user is responsible for their own actions.

#### CONTACT

If you have problems, questions, ideas or suggestions please contact
us by posting to<EMAIL_ADDRESS>
#### WEB SITE

Visit our homepage for the latest info and updated tools

https://nr1.nu & https://github.com/wuseman/

#### END!

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
=== rcv

Probably the most esoteric part of this script is this function:

```
rcv() { local -n ret=$1; $2 ret "${@:3}"; }
```

From first glance this function exists as syntactic sugar for moving the return variable first that can be safely removed.

It is not merely that. It is a design pattern intended to pre-empt any mandelbugs from a particular bash local variable namespace papercut, as seen below:

```

format_headline() {
   local -n ret_headline=$1;
   local headline=$2;
   ret_headline=`echo $headline | tr '[:lower:]' '[:upper:]'`
}

rcv() { local -n ret=$1; $2 ret "${@:3}"; }

control() {
    local raw_headline='temperate weather'

    local new_headline
    format_headline new_headline raw_headline
    echo $new_headline
    # prints out 'TEMPERATE WEATHER'
}

# bug occurs regardless of whether return var
# previously declared locally or globally or
# not previously declared
bug() {
    local raw_headline='temperate weather'

    local headline
    format_headline headline raw_headline
    echo $headline
    # prints out nothing, var is undefined.
}

use_rcv_pattern(){
    local raw_headline='temperate weather'

    local headline
    rcv headline format_headline raw_headline
    echo $headline
    # prints out 'TEMPERATE WEATHER'
}

```

Here is a more subtle example of the bug which shows how the bug can occur as long as there is not an intermediate label for the return variable, the 'control' and 'bug' and 'rcv pattern' fns are unchanged in this example.

```

_headline_timestamp() {
   local -n timestamped_headline=$1
   local headline=$2
   timestamped_headline="$headline received `date +%s`"
}

format_headline() {
   local -n ret_headline=$1;
   local -r anycased=$2
   local -r uppercased=`echo $anycased | tr '[:lower:]' '[:upper:]'`
   _headline_timestamp $1 uppercased
}

```

repository: nathanross/StampedIron

repo_name: nathanross/StampedIron


text:
# chirpstack-api

ChirpStack gRPC API message and service wrappers for Javascript. Typescript definitions are included.

## Install

With npm:

```sh
npm install @chirpstack/chirpstack-api --save
```

Or with yarn:

```sh
yarn add @chirpstack/chirpstack-api
```

## Usage

All messages, services, constants, etc. are auto-generated from the ChirpStack protobuf definitions. The result is that
this package structure matches that of the protobuf definitions. There is no ES6 index gathering all of the exports, so
full import/require paths should be used. The generated code is all callback based, but can be promisified.

The protobuf definitions can be found here: https://github.com/brocaar/chirpstack-api/tree/master/protobuf

The generated code all depends on the `grpc` package, and for most use cases you will probably need to make use of the
`grpc` package directly as well. This is seen in the example below.

### Example

This example shows how to log in to ChirpStack via the gRPC API and then create a gRPC metadata object containing the
JWT. This metadata could then be passed to any future requests that require authorization.

```javascript
import * as grpc from '@grpc/grpc-js';

import * as internalService from '@chirpstack/chirpstack-api/as/external/api/internal_grpc_pb';
import * as internalMessages from '@chirpstack/chirpstack-api/as/external/api/internal_pb';

// Create the client for the 'internal' service
const internalServiceClient = new internalService.InternalServiceClient(
    'localhost:8080',
    grpc.credentials.createInsecure()
);

// Create and build the login request message
const loginRequest = new internalMessages.LoginRequest();

loginRequest.setEmail('email');
loginRequest.setPassword('password');

// Send the login request
internalServiceClient.login(loginRequest, (error, response) => {
    // Build a gRPC metadata object, setting the authorization key to the JWT we
    // got back from logging in.
    const metadata = new grpc.Metadata();
    metadata.set('authorization', response.getJwt());

    // This metadata can now be passed for requests to APIs that require authorization
    // e.g.
    // deviceServiceClient.create(createDeviceRequest, metadata, callback);
});
```

repository: brocaar/chirpstack-api

gha_language: Python

gha_license_id: MIT

repo_name: brocaar/chirpstack-api


text:
# Stripe Payment Provider Integration for django-shop

This integrates the Stripe for django-shop version 0.9 and above.

## Installation

for django-shop version 0.9.x:

```
pip install djangoshop-stripe==0.1.4
```

for django-shop version 0.10.x:

```
pip install djangoshop-stripe==0.2.0
```

## Configuration

In ``settings.py`` of the merchant's project:

Add ``'shop_stripe'`` to ``INSTALLED_APPS``.

At [Stripe](https://stripe.com/) create an account and apply for a public/private key-pair. Then add
these keys:

```
SHOP_STRIPE = {
    'PUBKEY': 'pk_<public-key-as-delivered-by-Stripe>',
    'APIKEY': 'sk_<api-key-as-delivered-by-Stripe>',
    'PURCHASE_DESCRIPTION': _("Thanks for purchasing at MyShop"),
}
```

Add ``'shop_stripe.modifiers.StripePaymentModifier'`` to the list of ``SHOP_CART_MODIFIERS``.

Add ``'shop_stripe.payment.OrderWorkflowMixin'`` to the list of ``SHOP_ORDER_WORKFLOWS``.

Add ``'shop_stripe.context_processors.public_keys'`` to the list of template
``OPTIONS['context_processors']``

## Changes

### 0.3.0
* Upgrade to ``stripe`` version 1.53 and ``angular-stripe`` version 4.2.13.

### 0.2.2
* Replace ``{% addtoblock "ext-js" %}`` against ``{% addtoblock "js" %}``, since Django-SHOP 0.10.0
  can handle externally referenced files as well.

### 0.2.1
* Adopted for django-SHOP version 0.10. Do not use this version for Django-SHOP 0.9.x.
* Stripe form template can be used by static views, rendering the PaymentMethodForm manually.

### 0.2.0
* Replaced ``bower`` against ``npm``.
* Replaced Sekizai block ``shop-ng-requires`` against ``ng-requires``.
* Replaced Sekizai block ``shop-ng-config`` against ``ng-config``.
* Since Ben Drucker is [unwilling](https://github.com/bendrucker/angular-stripe/issues/50) to
  provide an installable ``angular-stripe.js`` module, it is build and shipped with
  **djangoshop-stripe**.

### 0.1.4
Fixed Python3 compatibility issue.

### 0.1.3
In django-angular the naming scheme changed. Reflect these changes.

### 0.1.2
Adopted for asynchronous payments as available in django-shop-0.9.0rc2.

### 0.1.1
Initial working release.


text:
# @umijs/deps

[![Install size](https://badgen.net/packagephobia/install/@umijs/deps)](https://packagephobia.now.sh/result?p=@umijs/deps)

Pre-compiled umi deps.

**NOTICE: Internal package, do not depend on it directly.**

## LICENSE

MIT

repository: FwjGithub/stuSystem

repo_name: FwjGithub/stuSystem


text:
redis-dump-load
===============

.. image:: https://api.travis-ci.org/p/redis-dump-load.png
  :target: https://travis-ci.org/p/redis-dump-load

Dumps Redis data sets into a format suitable for long-term storage
(currently JSON) and loads data from such dump files back into Redis.

Features
--------

redis-dump-load:

- Supports all Redis data types;
- Dumps TTL and expiration times;
- Can load TTL OR original expiration time for expiring keys;
- Can create pretty/human-readable dumps (keys dumped in sorted order,
  output indented);
- Can stream data when dumping and loading;
- Can be used as a module in a larger program or as a standalone utility;
- Uses an output format compatible with redis-dump_.

Usage
-----

redis-dump-load may be used as a module and also as a command line tool.

Module Usage
^^^^^^^^^^^^

redis-dump-load exports a pickle_-like interface, namely ``load``,
``loads``, ``dump`` and ``dumps`` functions. For example::

    import redisdl

    json_text = redisdl.dumps()

    with open('path/to/dump.json', 'w') as f:
        # streams data
        redisdl.dump(f)

    json_text = '...'
    redisdl.loads(json_text)

    with open('path/to/dump.json') as f:
        # streams data if ijson or jsaone are installed
        redisdl.load(f)

See the streaming section below for more information about streaming.

Dump and load methods accept options as keyword arguments::

    json_text = redisdl.dumps(encoding='iso-8859-1', pretty=True)

The arguments should always be passed in as keywords, i.e, do not rely
on the order in which the parameters are currently listed.
Options take string values unless otherwise noted. The options are as follows:

- ``host``: host name or IP address for redis server
- ``port``: port number for redis server
- ``unix_socket_path``: connect to redis via a Unix socket instead of TCP/IP;
  specify the path to the socket
- ``password``: specify password to connect to redis
- ``db`` (integer): redis database to connect to
- ``encoding``: encoding to use for encoding or decoding the data, see
  Unicode section below
- ``pretty`` (boolean, dump only): produce a pretty-printed JSON which is
  easier to read; currently this makes ``dump`` load entire data set into
  memory rather than stream it
- ``keys`` (dump only): only dump keys matching specified pattern
- ``use_expireat`` (boolean, load only): use ``expireat`` in preference to ``ttl`` when loading expiring keys
- ``empty`` (boolean, load only): empty the redis data set before loading the
  data
- ``streaming_backend`` (string): streaming backend to use when loading via
  ``load`` method, if ijson_ or jsaone_ is installed and streaming is thus used

Command Line Usage
^^^^^^^^^^^^^^^^^^

``redisdl.py`` can be used as a command line tool as follows::

    # dump database 0
    ./redisdl.py > dump.json
    ./redisdl.py -o dump.json

    # load into database 0
    ./redisdl.py -l < dump.json
    ./redisdl.py -l dump.json

For convenience, ``redisdl.py`` can be hard or soft linked as follows::

    ln redisdl.py redis-dump
    ln redisdl.py redis-load

Now it can be used thusly::

    # dump database 0
    ./redis-dump > dump.json
    ./redis-dump -o dump.json

    # load into database 0
    ./redis-load < dump.json
    ./redis-load dump.json

Symlinks work as well. "load" in the executable name triggers the loading
mode, "dump" triggers the dumping mode, otherwise the default is to dump
and ``-l`` option switches into the loading mode.

All options supported by the module API are accepted when redisdl is invoked
as a command line tool. The command line options are:

- ``-h``/``--help``: help text
- ``-H HOST``/``--host HOST``: specify redis host
- ``-p PORT``/``--port PORT``: specify redis port
- ``-s SOCKET_PATH``/``--socket SOCKET_PATH``: connect to Unix socket at
  the specified path
- ``-w PASSWORD``/``--password PASSWORD``: password to use when connecting to redis
- ``-d DATABASE``/``--db DATABASE``: redis database to connect to (integer)
- ``-k PATTERN``/``--keys PATTERN`` (dumping only): dump only keys matching specified glob-style pattern
- ``-E ENCODING``/``-encoding ENCODING``: specify encoding to use
- ``-o PATH``/``--output PATH``: write dump to PATH rather than standard output
- ``-y``/``--pretty`` (dumping only): pretty-print JSON
- ``-A``/``--use-expireat`` (loading only): use ``expireat`` rather than ``ttl`` values in the dump
- ``-e``/``--empty`` (loading only): empty redis data set before loading
- ``-B BACKEND``/``--backend BACKEND`` (loading only): streaming backend to use

Streaming
---------

``dump`` will stream data unless ``pretty`` is given and ``True``.

``load`` will stream data if ijson_ or jsaone_ is installed. To determine whether
redis-dump-load supports streaming data load, examine
``redisdl.have_streaming_load`` variable. There are also
``redisdl.have_ijson`` and ``redisdl.have_jsaone`` variables indicating
presence of the respective library.

redis-dump-load prefers ijson over jsaone and does not specify a backend for
ijson by default, which as of this writing means that ijson's pure Python
backend will be used. To request a specific backend either pass it as
follows to the load methods::

    redisdl.load(io, streaming_backend='ijson-yajl2')

... or set the desired backend globally as follows::

    redisdl.streaming_backend = 'ijson-yajl2'

The backend argument takes form of "library-library backend", e.g.:
- ``ijson`` selects the default backend of ijson, which currently is the pure Python one.
- ``ijson-yajl2`` selects ijson with yajl2 backend.
- ``yajl2`` means the same things as ``ijson-yajl2`` for compatibility with older redis-dump-load versions.
- ``jsaone`` selects the jsaone backend.

Note: Streaming loading is substantially slower than lump loading.
To force lump loading of files, read the files in memory and invoke ``loads``
rather than ``load``.

jsaone support was added in redis-dump-load version 1.0.

TTL, EXPIRE and EXPIREAT
------------------------

When dumping, redis-dump-load dumps the TTL values for expiring keys
as well as calculated time when the keys will expire (``expireat``).
As Redis does not provide a command to retrieve absolute expiration time of
a key, the expiration time is calculated using the current time on the
*client*'s system. As such, if the time on the client system is not in sync
with time on the system where the Redis server is running, ``expireat``
values will be incorrect.

When loading, redis-dump-load by default uses the TTL values in the dump
(``ttl`` key) to set expiration times on the keys in preference to
``expireat`` values. This will maintain the expiration times of the keys
relative to the dump/load time but will change the absolute expiration time
of the keys. Using ``-A``/``--use-expireat`` command line option or
``use_expireat`` parameter to module functions will make redis-dump-load
use ``expireat`` values in preference to ``ttl`` values, setting expiring
keys to expire at the same absolute time as they had before they were dumped
(as long as system times are in sync on all machines involved).

Dumping and loading of TTL values and expiration times was added in
redis-dump-load version 1.0.

Unicode
-------

Redis operates on bytes and has no concept of Unicode or encodings.
JSON operates on (Unicode) strings and cannot serialize binary data. Therefore,
redis-dump-load has to encode Unicode strings into byte strings when
loading data into Redis and decode byte strings into Unicode strings
when dumping data from Redis.
By default redis-dump-load uses utf-8 for encoding data sent to Redis
and decoding data received from Redis.
This behavior matches redis-py, whose default encoding is utf-8.
A different encoding can be specified.

``dumps`` returns strings, that is, instances of ``str`` on Python 2
and instances of ``unicode`` on Python 3.

When dumping to an IO object using ``dump``, and the IO object accepts
byte strings (such as when a file is opened in binary mode),
redis-dump-load will ``.encode()`` the dumped data using the default
encoding in effect.

ijson's yajl2 backend can only decode ``bytes`` instances, not ``str``.
When loading data from a file opened in text mode and using ijson-yajl2,
redis-dump-load will encode the file data using utf-8 encoding before
passing the data to ijson. If this fails, try opening the file/stream in
binary mode.

jsaone can only decode text strings (``str`` instances), not ``bytes``.
When loading data from a file opened in binary mode and using jsaone,
redis-dump-load will decode the file data using the default encoding.
If this fails, you can change the default encoding or open the files in text
mode with the encoding appropriately specified in the ``open()`` call.

Concurrent Modifications
------------------------

redis-dump-load does not lock the entire data set it is dumping,
because Redis does not provide a way to do so.
As a result, modifications to the data set made while a dump is in progress
affect the contents of the dump.

Dependencies
------------

- redis-py_
- ijson_ or jsaone_ (optional, for streaming load)
- simplejson_ (Python 2.5 only)

Tests
-----

redis-dump-load has a test suite. To run it, install nose_ and run::

    nosetests

There are several tests that check for race conditions and as such take
a long time to run. To skip them, invoke nose thusly::

    nosetests -a '!slow'

License
-------

Released under the 2 clause BSD license.

.. _redis-dump: https://github.com/delano/redis-dump
.. _redis-py: https://github.com/andymccurdy/redis-py
.. _simplejson: http://pypi.python.org/pypi/simplejson/
.. _pickle: http://docs.python.org/library/pickle.html
.. _nose: https://nose.readthedocs.org/en/latest/
.. _ijson: https://pypi.python.org/pypi/ijson
.. _jsaone: http://pietrobattiston.it/jsaone

repository: cultivateai/redis-dump-load

extension: rst

repo_name: cultivateai/redis-dump-load


text:
# Magnetite
Magnetite is an Open Source voxel game & engine, it is powered by:

  * OpenGL
  * SFML
  * Bullet Physics
  * C++
  * CMake

It is crafted with love and care by:

 * Daniel Evans - http://bytecove.co.uk
   * Programming, 'Art'
 * Samuel Clements - http://borntyping.co.uk
   * Linux
 * Howell Duggan
   * Art

## Game
To run the game, use the ``--game`` flag to select a game mode.
Current game modes include:
 + fortress
 + sandbox

### Key bindings
 * To move, use `WASD`.

 * In fortress mode, To turn left and right, use `QE`.
 * In fortress mode, To alter your altitude, use `XZ`.

 * In sandbox mode, use ``space`` to toggle flying.
 * In sandbox mode, use ``RF`` to switch between blocks.
 * In sandbox mode, press ``Alt`` to show the block menu.
 * In sandbox mode, use ``MOUSE2`` to toggle between build modes (add, delete, explode, and plant tree).
 * Use `SPACE` to access the menu.
 * Use the `up` and `down` cursor keys to navigate the menu.
 * Use `enter` to select an option.
 * Use `bksp` to return to the previous menu.

## Licence
Copyright (C) 2011-2013  Daniel Lloyd Evans

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: miivers/Magnetite

extension: markdown

repo_name: miivers/Magnetite


text:
# Covid19-Tracker
A React JS application that tracks COVID-19 Status.

## Project Description

Watching the news about Covid-19 daily, the numbers and data gets everyone's attention. The data can tell us that the virus is spreading quickly through the specific region or entire world. What can we, as developers, do to make the situation better? We can help to spread awareness by visualizing the data.

## Technology

* [React](https://github.com/facebook/create-react-app)
* [Material UI](https://material-ui.com/)
* [Chart.js](https://www.chartjs.org/)
* [mathdroid api](https://github.com/mathdroid/covid-19-api)

## Scope

The project is going to fetch the live data from the API using Async/Await syntax. The data is fetched from the API and it will create cards displaying the statistics as well as Charts. The data of this statistics accessed from the mathdroid API, which serving data from John Hopkins University CSSE.

## Overview

* The initial state of the data display is total number around the world.
* User can view number of cases of Covid-19 for infected, recovered, deaths.
* User may select desired country to display the result.
* User may filter by check/uncheck infected and/or deaths display for chart.
* The selected country will display in bar view.
* Due to API constraints, some data might not be able to display in real-time. E.g recovered cases data will not display for initial chart view.

gha_language: JavaScript


text:
437\. Path Sum III

Medium

Given the `root` of a binary tree and an integer `targetSum`, return _the number of paths where the sum of the values along the path equals_ `targetSum`.

The path does not need to start or end at the root or a leaf, but it must go downwards (i.e., traveling only from parent nodes to child nodes).

**Example 1:**

![](https://assets.leetcode.com/uploads/2021/04/09/pathsum3-1-tree.jpg)

**Input:** root = [10,5,-3,3,2,null,11,3,-2,null,1], targetSum = 8

**Output:** 3

**Explanation:** The paths that sum to 8 are shown.

**Example 2:**

**Input:** root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22

**Output:** 3

**Constraints:**

*   The number of nodes in the tree is in the range `[0, 1000]`.
*   -109 <= Node.val <= 109
*   `-1000 <= targetSum <= 1000`

repository: javadev/LeetCode-in-Java

branch_name: refs/heads/main

gha_language: Java

repo_name: javadev/LeetCode-in-Java


text:
## Budget Alerts Policy

### What it does

This Policy Template is used to determine if a Billing Center or the entire Organization has exceeded its monthly cost budget.

### Functional Details

- This policy supports a single target (ie. 1 specific Billing Center or the entire Organization). In order to apply a budget alert for multiple targets, you will need to apply this policy multiple times.
- Actual Spend budget alerts will raise an incident when the target has exceeded the budget for the month
- Forcasted Spend budget alerts will raise an incident when the target's runrate is on track to exceed the budget for the month

#### Input Parameters

This policy has the following input parameters required when launching the policy.

- *Monthly Budget* - specify the monthly budget.  Currency is irrelevant; the policy will default to whichever currency is used in Optima.
- *Budget Scope* - Organization or Billing Center
- *Billing Center Name* - if the scope is "Billing Center", supply the name of the target Billing Center
- *Cost Metric* - specify options for amortized vs nonamortized and blended vs unblended costs
- *Budget Alert Type* - Actual Spend or Forecasted Spend
- *Email addresses of the recipients you wish to notify* - A list of email addresses to notify

### Required RightScale Roles

- policy_manager
- billing_center_viewer (note: this role must be applied at the Organization level)

### Supported Clouds

- AWS
- Azure
- Google

### Cost

This Policy Template does not incur any cloud costs.


text:
# FizzBuzz JavaScript

Test Driven Development (TDD) and Pair Programming challenge with Jasmine and Javascript

##How it works:

The program is passed a number.
When passed a number that is a multiple of 3, the program returns the message "fizz".
When passed a number that is a multiple of 5, the program returns the message "buzz".
When passed a number that is a multiple of 3 and 5, the program returns the message "fizzbuzz".
When the number is neither of the above, the number is returned.

## How to Run

Open file in browser.
On the console, type:

```
for (var i = 1; i <= 100; i++) {
  console.log(fizzBuzz.says(i));
}
```

repository: j-rods/js-fizzbuzz

repo_name: j-rods/js-fizzbuzz


text:
---
name: Bug report
about: Create a report to help us improve
title: ''
labels: bug
assignees: ''

---

<!-- If you suspect this could be a bug, follow the template. -->

### What version of GraphJin are you using? `graphjin version`

### Have you tried reproducing the issue with the latest release?

### What is the hardware spec (RAM, OS)?

### Steps to reproduce the issue (config used to run GraphJin).

### Expected behaviour and actual result.

repository: dosco/graphjin

gha_language: Go

repo_name: dosco/graphjin


text:
# install your GitHub repository through "pip install"!!
This is demo repository for "pip install git+githubURL".
Try install **this repository** with super simple way as below!!

```bash
pip install "git+https://github.com/tarepan/pipinstallgithub#egg=mypipgh"
```

then use the **mypipgh** package in python as below!!

```python
from mypipgh.checker import hello

hello()
# "hello world, I am from GitHub!!"
```

As common library repository, entire project page itself is not package.
Instead, **packs** subdirectory is distributable package.

repository: tarepan/pipinstallgithub

repo_name: tarepan/pipinstallgithub


text:
---
title: " Making a Snapshot Release of JGit"
sidebar: gerritdoc_sidebar
permalink: dev-release-jgit.html
---
This step is only necessary if we need to create an unofficial JGit
snapshot release and publish it to the [Google Cloud
Storage](https://developers.google.com/storage/).

## Prepare the Maven Environment

First, make sure you have done the necessary [configuration in Maven
`settings.xml`](dev-release-deploy-config.html#deploy-configuration-settings-xml).

To apply the necessary settings in JGit’s `pom.xml`, follow the
instructions in [Configuration for Subprojects in
`pom.xml`](dev-release-deploy-config.html#deploy-configuration-subprojects),
or apply the provided diff by executing the following command in the
JGit workspace:

```
  git apply /path/to/gerrit/tools/jgit-snapshot-deploy-pom.diff
```

## Prepare the Release

Since JGit has its own release process we do not push any release tags.
Instead we will use the output of `git describe` as the version of the
current JGit snapshot.

In the JGit workspace, execute the following command:

```
  ./tools/version.sh --release $(git describe)
```

## Publish the Release

To deploy the new snapshot, execute the following command in the JGit
workspace:

```
  mvn deploy
```

## GERRIT

Part of [Gerrit Code Review](index.html)

## SEARCHBOX

repository: omunroe-com/gerrihmpg

repo_name: omunroe-com/gerrihmpg


text:
# NaiveC

Naive C compiler

## Environment

* LLVM 3.9.0
* Clang
* CMake

## Usage

```bash
cmake [-DCMAKE_INSTALL_PREFIX="/tmp/llvm"] .
make
./naive_c tests/kmp.c # run compiler, ir will output to stderr, bc will write to file
lli tests/kmp.bc # interpret bytecode
llc tests/kmp.bc # compile to assembly language
```

You should ensure LLVM in your path so that cmake can find it, or you can run cmake with `-D CMAKE_INSTALL_PREFIX` option.

repository: hawkingrei/NaiveC

repo_name: hawkingrei/NaiveC


text:
# Welcome to Gecko!

[![Open Source Love](https://badges.frapsoft.com/os/v2/open-source.svg?v=103)](https://github.com/ellerbrock/open-source-badges/)
[![MIT Licence](https://badges.frapsoft.com/os/mit/mit.svg?v=103)](https://opensource.org/licenses/mit-license.php)

This is a tool that uses the citation relations between scientific papers to help researchers find interesting and relevant papers.

The user specifies several 'seed' papers which define the specific area of the scientific landscape they are interested in.

The tool then searches several databases to find the papers that cite or are cited-by the seed papers.

Papers that are cited by a lot of the seed papers are likely to be important foundational papers in the field (or certainly worth being aware of at least).

Papers that cite a lot of the seed papers are likely to be more recent papers in the same area that might be worth reading.

The tool allows the user to view these highly connected papers either in a table or in the context of the network.

## Setting up Gecko to run locally

1. Clone the repo (or just download as a zip)

```
git clone https://github.com/bjw49/citation-network-explorer.git

```

2. To be able to use the Microsoft Academic Graph you'll need an API key for the Microsoft Academic Knowledge API from [here](https://azure.microsoft.com/en-gb/try/cognitive-services/?api=academic-knowledge-api). You can use the tool without one but the title search functionality won't work and the coverage of the Open Citation Corpus isn't as good yet (though it is growing every day).

2. If you have an API key, open the file `microsoft.js` in a text editor and paste the API key into the line below (making the obvious substitution):

```javascript

MICROSFT_API_KEY = "YOUR API KEY GOES HERE"

```

## Instructions for use

1. Open GeckoApp.html (in the /public folder) or go to [http://citationgecko.com](http://citationgecko.com)
2. To get started add some seed papers by clicking the 'add more seed papers' button in the left-hand panel.
2. There are three ways of choosing seed papers to start with:
    1. Add directly by DOI
    2. Upload a bibTex file (NOTE: currently only entries with a DOI will be added)
        * There is an example BibTex in the repository (exampleBibTex.bib) which you can try importing as a test case.
    3. Search for seed papers by title
        * Papers with titles containing the query words are displayed in a table.
        * Choose which papers to add as seeds by clicking the Add buttons at the end of each row.
3. The seed papers added are listed in the left-hand panel and connections between them shown graphically in the right hand panel.
4. For a list of the papers connected to these seed papers click the 'Connected' tab in the left-hand panel. Papers can sorted by "Seeds Cited" or "Seeds Cited-By" in order to find highly connected papers.
5. In order to hide less well connected papers from the Network View use the Threshold Slide to select the minimum number of connections to be displayed.
6. You can switch between viewing a graph showing only references of the seed papers and a graph showing only the papers that cite the seed papers by clicking the toggle between 'Papers Cited-By Seed Papers' and 'Papers Citing Seed Papers' that also acts as a key.
6. If one of the connected papers seems highly relevant you can add it as a seed paper either from the list view or network view, expanding the network in order to uncover more papers.

repository: biomadeira/citation-network-explorer

repo_name: biomadeira/citation-network-explorer


text:
---

This work is licensed under the Creative Commons CC0 License

---

# Update import to create satisfactions
### xtUML Project Implementation Note

1. Abstract
-----------
Currently component references get automatically assigned, and interface references get formalized, but satisactions do not get created. This issue is raised to auto create satisfaction during import of a MASL model.

2. Document References
----------------------
In this section, list all the documents that the reader may need to refer to.
Give the full path to reference a file.
2.1 [BridgePoint DEI #8484](https://support.onefact.net/issues/8484)
Update import to create satisfactions.
2.2 [BridgePoint DEI #8364](https://support.onefact.net/issues/8364)
Adapt BridgePoint model import to copy MASL activities to their proper locations.
2.3 [BridgePoint DEI #8977](https://support.onefact.net/issues/8977)
Manual test for automatic satisfaction creation.
2.4 [BridgePoint DEI #8978](https://support.onefact.net/issues/8978)
Graphics reconciliation is not connecting the ball and cup in a satisfaction.

3. Background
-------------
During the process of migrating a MASL model to xtUML a single-file xtuml model
is created. This model contains some annotation that helps the model importer
know how to process the model. A prior task, [[2.2]](#2.2), introduced the
blueprint for how MASL artifacts are migrated into a xtUML model
(the blueprint here refers to the ImportHelper.java::resolveMASLProject()
operartion).
This issue is raised to extend the work from [[2.2]](#2.2) to perform the
task of automatically creating satisfactions between formalized provisions and
requirements that have been annotated to indicate that a satisfaction is
warranted.

In the single-file xtuml model being imported, each package that contains
masl interfaces that need to be satisfied shall contain the following text
string in the package description: masl_project

Since the this task is specific to creating satisfactions for MASL project
there are constraints from the MASL convert that can be used to limit the
required work.

3.1 The package that contains provisions and requirements to be satisfied shall
contain a description that includes the string: masl_project.

3.2 There is a 1:1 mapping between provisions and requirements that shall be
satisfied. For each provision there is no more than 1 requirement that to
provide a satisfaction to. This means as soon as a satisfaction exists, against
a given provision or requirement no more satisfactions are needed.

4. Requirements
---------------
4.1 For each unsatisfied provision search the package for a matching
requirement and create a satisfaction if a match is found.
4.2 Create no more than 1 satisfaction per requirement and provision.
4.3 The satisfaction shall be created in the package that that contains the
{imported}provision/{imported}requirement being satisfied.
4.4 The graphics associated with the satisfaction must be reconciled [[2.4]](#2.4).

5. Work Required
----------------
5.1 Modify ImportHelper.java::resolveMASLproject() that was introduced with
[[2.2]](#2.2) and follow the pattern provided to introduce functionality that
iterates over each marked package to create satisfactions as specified
by the requirements.

5.2 Introduce OAL that creates the satisfactions
5.2.1 Introduce ooaofooa::Functions::autoCreateSatisfactions
Here is the pseudo-code:
```
find all provisions in the given package
find all imported provisions in the given package
find all requirements in the given package
find all imported requirments in the given package
for each provision
  if not satisfied yet
    for each requirement
      find a match to the provision by name
      if found
        create satisfaction
      end if
    end for
  end if
  if not satisfied yet
    for each imported requirement
      find a match to the provision by name
      if found
        create satisfaction
      end if
    end for
  end if
end for

repeat the above look with imported provisions

```

6. Implementation Comments
--------------------------
6.1 During testing it was found that graphics reconciliation of satisfactions
is not working. The "ball and cup" are not being connected. This problem
existed prior to this task, and is being handled by a separate issue
[[2.4]](#2.4). However, this is a blocker for this task. The reason this is
a blocker is that once the satisfaction is created, if the graphics reconciliation
does not connect the "ball and cup". The user is left worse off then had auto satisfaction
never happend because they are unable to connect the ball and cup manually without first
unsatisfying the interface.

7. Unit Test
------------
7.1 Run the manual test defined by [[2.3]](#2.3).

8. User Documentation
---------------------
none

9. Code Changes
---------------
Fork/Repository: rmulvey
Branch: 8484_create_satisfaction_on_import

doc-bridgepoint/notes/8484_masl_auto_satisfaction_creation/
    8484_masl_auto_satisfaction.int.md

org.xtuml.bp.core/models/org.xtuml.bp.core/ooaofooa/Functions/Functions.xtuml

org.xtuml.bp.io.core/src/org/xtuml/bp/io/core/ImportHelper.java

End
---

gha_language: HTML


text:
# Covid :dizzy_face: lockdown :lock: tracker :hourglass:

Are you **sick** and **tired** of googling the 14 day average of new covid cases every day?

It pulls data from a [Guardian Austraia](https://services1.arcgis.com/vHnIGBHHqDR6y0CR/arcgis/rest/services/COVID19_Time_Series/FeatureServer/0/query?where=1%3D1&outFields=*&outSR=4326&f=json) API, calculates the average and then shoots the message to a Discord channel, given by YOU! The user!

## Usage
In order to run the bot, ya gotta have an environment file. By default, you can make one in the root folder and call it `.env`.


text:
## j-Xterm

The component renders a terminal output/input directly in the web browser. __IMPORTANT__: the example doesn't work as you expect, it needs a real terminal output.

__Configuration__:

- `cols {Number}` count of cols (default: `80`)
- `rows {Number}` count of rows (default: `24`)
- `send {String}` a link to the `function(data)` for the communication with the server

__Methods__:

- `instance.write(data)` writes data into the terminal component

__Used dependencies__:

- [Xterm.js](https://xtermjs.org/)
- [Full example](https://github.com/totaljs/examples/tree/master/remote-terminal)

### Author

- Peter Širka<EMAIL_ADDRESS>- [License](https://www.totaljs.com/license/)

repository: totaljs/components

repo_name: totaljs/components


text:
# Oath::Generators

Rails generators for adding in authentication components, using the
[Oath](https://github.com/halogenandtoast/oath) authentication library.

## Installation

Add this line to your application's Gemfile:

    gem 'oath-generators'

And then execute:

    $ bundle

## Generators

Currently these are the generators available:

### Scaffold

You can generate a basic starting point for any oath app by running the following:

    rails g oath:scaffold

### Password Reset

If you'd like to generate basic password reset for your app, you can run:

    rails g oath:password_reset

This will generate the necessary files for an implementation of resetting
a user's password. It will ask you for host names for development, test
and production environments in order to make the mailer work.

### Google Oauth 2

If you'd like setup basic google oauth authentication, you can run:

    rails g oath:google_oauth2

This will generate the necessary files for an implementation of allowing users
to sign in either with an email/password or by using google oauth2.

## Contributing

1. [Fork it](http://github.com/halogenandtoast/oath-generators/fork)
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create new Pull Request

repository: halogenandtoast/oath-generators

gha_language: Ruby

repo_name: halogenandtoast/oath-generators


text:
#

[![documentation](https://github.com/bongoman-by/svvs/actions/workflows/generateDocs.yml/badge.svg)](https://github.com/bongoman-by/svvs/actions/workflows/generateDocs.yml)

SVVS is an open source project and [YouTube channel](https://www.youtube.com/channel/UCE8ux2eOsw_X7XVrI5mpYkg) showcasing application development in the [Nx](https://nx.dev) mono repository.

---

## nx-angular-next as client

It is Angular application providing frontend client

---

### Technologies used

[Nx](https://nx.dev)
• [NestJs](https://nestjs.com)
• [GraphQL](https://graphql.org/)
• [Docker](https://www.docker.com/)
• [PostgreSQL](https://www.postgresql.org/)

### Documentation

[backend-api](https://bongoman-by.github.io/svvs/api/)
• [nx-angular-next](https://bongoman-by.github.io/svvs/nx-angular-next/)
• [admin](https://bongoman-by.github.io/svvs/api/)

repository: bongoman-by/svvs

gha_language: TypeScript

repo_name: bongoman-by/svvs


text:
---
layout: default
category: news
published: true
title: "Updates to HilaryBisenieks.com"
tags: news
---

Maybe you noticed that something is a little... *different* around
here?

(If you're reading this and your address bar says github.io, these
aren't the droids you're looking for.)

For folks looking for the old blue and gray page, that's been
retired. Even with a lot of (hopefully invisible) improvements
on the backend, it was too much of a pain to manage, and there
were occasional security issues. Besides which, I wanted to do a
refresh and get something a little more mobile-friendly. As if
anyone other than me ever looks at my site on a mobile device...

Over the next few weeks, a lot of content will be returned to this
site in one way or another, but my hand's been forced a little:
it's either migrate now or pay for another year of hosting that I
don't really need.

Anyhow, if there's something that you're looking for that you swear
was here *just yesterday,* check back soon. Or email webmaster [at]
hilarybisenieks [dot] com.


text:
---
title: GSoC 2021 - Final Report
tags: GSoC
excerpt: false
layout: article
---

This is the final report for my GSoC project with SymPy.

Project Synopsis

My project consisted of 2 parts -

* Rational Riccati Solver - I implemented an ODE solver for Riccati equations with rational solutions. This solver is quite important as it can be used as a subroutine for other solvers like the Kovacic solver (for second order linear homogeneous ODEs), Lie group solver (for 1st order nonlinear ODEs), etc.

* ODE test suite - I created a test suite of all ODEs present in _Differential Gleichungen_ by Kamke in SymPy. This book consists of 1940 ODEs of various orders and linearities including systems of ODEs as well. It will be useful to check how many of these SymPy can solve and improve/add solvers based on the errors we encounter in these set of ODEs.

Additionally, I worked for sometime on `dsubs`, a function to facilitate substitutions in differential equations.

Work Accomplished

[#21459](https://github.com/sympy/sympy/pull/21459) - Rational Riccati Solver

[Test Suite Repository](https://github.com/naveensaigit/kamke_test_suite/) - A repository which contains all examples from Kamke. The repo has a way to run all the examples and generate a report in both human/machine readable format.

Work in Progress

[#20979](https://github.com/sympy/sympy/pull/20979) - PR for `dsubs`, a function for substitutions in differential equations.

Examples

Riccati ODEs

Any Riccati ODE with atleast 1 rational particular solution can now be solved in SymPy. Some examples are -
``` python
>>> from sympy import Symbol, Function, dsolve, checkodesol
>>> f = Function('f')
>>> x = Symbol('x')

>>> eq = -x**4*f(x)**2 + x**3*f(x).diff(x) + x**2*f(x) + 20
>>> sol = dsolve(eq, hint="1st_rational_riccati")
>>> sol
Eq(f(x), (4*C1 - 5*x**9 - 4)/(x**2*(C1 + x**9 - 1)))
>>> checkodesol(eq, sol)
(True, 0)

>>> eq = f(x).diff(x) + f(x)**2 - (2*x + 1/x)*f(x) + x**2
>>> sol = dsolve(eq, hint="1st_rational_riccati")
>>> sol
Eq(f(x), x*(C1 + x**2 + 1)/(C1 + x**2 - 1))
>>> checkodesol(eq, sol)
(True, 0)
```

Kamke Test Suite

To view the results of the test suite run against the latest version of SymPy, go to the [home page](https://naveensaigit.github.io/kamke_test_suite). To use the Kamke Test Suite, please clone the [repository](https://github.com/naveensaigit/kamke_test_suite). To run the entire test suite, run -
```
python test_kamke.py
```

This will generate a folder with the results of the run in JSON format. To generate HTML pages from these files, run -

```
python test_kamke.py --html
```

There are different ways to run the test suite using command line arguments. To view all the different ways to run the test suite, please refer to the [README](https://www.github.com/naveensaigit/kamke_test_suite/tree/gh-pages/README.md) of the repository.

Substitutions in ODEs

A basic transformation of `x -> t^2` can be achieved by -

``` python
>>> from sympy import symbols, dsubs, Function, cos
>>> f, g, h = symbols('f g h', cls=Function)
>>> x, a, t = symbols('x a t')
>>> eq = f(x).diff(x) + f(x)
>>> dsubs(eq, {x: t**2})
f(t**2) + Derivative(f(t**2), t)/(2*t)
```

Functions in the equation can be transformed too

``` python
>>> eq = f(x).diff(x, 2) + cos(x)
>>> dsubs(eq, {x: t**2, f(x): g(t)})
cos(t**2) + (Derivative(g(t), (t, 2))/(2*t)
- Derivative(g(t), t)/(2*t**2))/(2*t)

>>> dsubs(eq, {x: t, f(x): g(t)**2})
2*g(t)*Derivative(g(t), (t, 2)) + cos(t)
+ 2*Derivative(g(t), t)**2
```

To apply a transformation with number of new symbols greater than number of old symbols, a list of all new variables must be given. For example, a transformation `x = a t` where `t` is the new variable and `a` is a symbolic constant, would be done as -

``` python
>>> dsubs(eq, {x: a*t, f(x): g(t)}, [t])
cos(a*t) + Derivative(g(t), (t, 2))/a**2
```

We can do it similarly for functions as well.

``` python
>>> dsubs(eq, {x: t, f(x): h(a)*g(t)**2}, [t, g(t)])
2*g(t)*h(a)*Derivative(g(t), (t, 2))
+ 2*h(a)*Derivative(g(t), t)**2 + cos(t)
```

Let us see how `dsubs` works for some typical cases using an example of a homogeneous ODE which can be solved using the substitution `v = y(x)/x`.

``` python
>>> from sympy import symbols, Function, dsolve
>>> x, t = symbols('x t')
>>> y, v = symbols('y v', cls=Function)
>>> eq = y(x).diff(x) - (x**2 + y(x)**2)/(x*y(x))
```

Transform the homogeneous equation to a linear equation

``` python
>>> homeq = dsubs(eq, {x:t, y(x): t*v(t)}, [t, v(t)]).simplify()
>>> homeq
t*Derivative(v(t), t) - 1/v(t)
```

Find the solutions for the transformed equation

``` python
>>> solt1, solt2 = dsolve(homeq)
>>> solt1
Eq(v(t), -sqrt(C1 + 2*log(t)))
```

Re-substitute `v = y(x)/x` to get the solutions to the original equation

``` python
>>> sol = dsubs(solt1, {v(t): y(x)/x, t: x})
>>> sol
Eq(y(x)/x, -sqrt(C1 + 2*log(x)))
```

Let us look at another example - The 2nd order Cauchy Euler equation.

``` python
>>> x, a, b, t = symbols('x a b t')
>>> y, phi = symbols('y phi', cls=Function)
>>> eq = x**2*y(x).diff(x, 2) + a*x*y(x).diff(x) + b*y(x)
```

Transform the equation using the substitutions `x = e^t` and `y(x) = phi(t)`

``` python
>>> from sympy import exp, log, logcombine
>>> eqtrans = dsubs(eq, {x: exp(t), y(x): phi(t)}, [t, phi(t)]).simplify()
>>> eqtrans
a*Derivative(phi(t), t) + b*phi(t) - Derivative(phi(t), t) + Derivative(phi(t), (t, 2))
```

The equation is now transformed to a constant-coefficient equation.

``` python
>>> solt = dsolve(eqtrans)
>>> solt
Eq(phi(t), C1*exp(t*(-a - sqrt(a**2 - 2*a - 4*b + 1) + 1)/2) + C2*exp(t*(-a + sqrt(a**2 - 2*a - 4*b + 1) + 1)/2))
```

Re-substitute for `phi(t)` and `t` to get the solution for the original equation.

``` python
>>> sol = logcombine(dsubs(solt, {phi(t): y(x), t: log(x)}), force=True)
>>> sol
Eq(y(x), C1*x**(-a/2 - sqrt(a**2 - 2*a - 4*b + 1)/2 + 1/2) + C2*x**(-a/2 + sqrt(a**2 - 2*a - 4*b + 1)/2 + 1/2))
```

Future Work

[#21770](https://github.com/sympy/sympy/pull/21770/) - Solver for Part-1 of Kovacic Algorithm. I stopped working on this because it was not clear how to implement parts 2 and 3 of the Kovacic algorithm with the Riccati solver I added.

[#21704](https://github.com/sympy/sympy/pull/21704/) - I initally wrote a parser for Maple to parse the examples from Maple to SymPy. However, most examples could be parsed using `sympify`, so I didn't work on this during the project. However, it will be useful to have a parser for Maple just like how we have one for Mathematica.

Test Suite Repository - Currently, the test suite only contains ODEs from Kamke. There are about 2300 more ODEs from the book _Ordinary Differential Equations and Their Solutions_ by Murphy that can also be added to the test suite. They are available in Mathematica syntax [here](https://drive.google.com/file/d/1kwDlhBQwUh2H8KeBmovUzkMY3SCFCLPa/view?usp=sharing). We would have to use the `MmaTranslator` function in Maple to convert these ODEs into Maple syntax so that they can be easily parsed with `sympify`.

Conclusion

I have definitely learnt a lot during this summer! The journey from being new to open source to completing an entire project gives me a lot of satisfaction! I would like to sincerely thank my mentors [Oscar Benjamin](https://github.com/oscarbenjamin) and [Aaron Meurer](https://github.com/asmeurer) for helping me throughout the project by continuously reviewing my code and suggesting changes to make it more efficient! I would also like to thank [Nijso](https://github.com/bigfooted) for suggesting the idea for this project and his feedback during the initial days. Lastly, thanks to [Nasser M. Abbasi](https://github.com/nasser1) for his [website](https://www.12000.org) where he published a list of all ODEs from Kamke in Maple and Mathematica syntax. The test suite could not have been created without his work.


text:
---
url: /architecture-scenarios
title: Architecture Scenarios
description: Learn about the common architecture scenarios that you will use to solve the authorization and authentication needs of your application.
---
# Architecture Scenarios

This page describes the typical architecture scenarios we have identified when working with customers on implementing Auth0.

Click on any scenario to get more information.

## Application Configurations

These scenarios describe the different type of technology architectures your application may use, and how Auth0 can help for each of those.

Server Client + API

Server to server communication where a server “Client” needs to make secure calls to an API (“Resource Server”), but on behalf of the client vs. a user.

Single Sign-On for Regular Web Apps

Traditional web application which needs to authenticate users using OpenID Connect.

## Under Construction

These scenarios are under construction and will soon be updated. Some describe the different type of technology architectures your application may use, while others describe the architecture depending on the type of businesses (B2C, B2B, B2E), and how Auth0 can help in each of these scenarios.

SPA + API

Single Page Web Application which talks to an API. The application will use OpenID Connect with the Implicit Grant Flow to authenticate users with Auth0.

Mobile + API

Mobile Application which talks to an API. The application will use OpenID Connect with the Authorization Code Grant using Proof Key for Code Exchange (PKCE) to authenticate users.

Regular Web App (using SAML)

Traditional web application which needs to authenticate users using SAML2.

  <% cache.find('articles/architecture-scenarios/business', {sort: 'order'}).forEach(article => { %>
    <a href="<%- article.url %>" class="architecture-scenarios-card">

        <img src="<%- article.image %>" alt="Architecture Diagram">

<%- article.title %>

<%- article.extract %>

  <% }); %>


text:
# "Exit Poll" Classification Algorithms

## Based on the Paper

You can find our paper here : https://arxiv.org/abs/2011.13832

>Supervised text classification is a classical and active area of ML research. In large enterprise, solutions to this problem has significant importance. This is specifically true in ticketing systems where prediction of the type and subtype of tickets given new incoming ticket text to find out optimal routing is a multi billion dollar industry.
>In this paper authors describe a class of industrial standard algorithms which can accurately ( 86\% and above ) predict classification of any text given prior labelled text data - by novel use of any text search engine.
>These algorithms were used to automate routing of issue tickets to the appropriate team. This class of algorithms has far reaching consequences for a wide variety of industrial applications, IT support, RPA script triggering, even legal domain where massive set of pre labelled data are already available.

## Test Data Set

You can download the data sets from :

1. https://www.kaggle.com/crowdflower/twitter-airline-sentiment
2. https://www.kaggle.com/kazanova/sentiment140

## Setup System

1. Create a directory called `data_dir`
2. Download the csv files inside them.
3. Install `whoosh` library for python
4. For unknown reason we have used `python 2`.  If you do not like it, you can update to `Python3`.
5. There are two different files you can run to check how they are performing.
   1. `cl_1_whoosh.py` which handles Airline Tweets.
   2. `cl_2_whoosh.py` which handles the millions of tweets

## Algorithms & Results

We have implemented (? It is a joke) two basic methods - do nothing counter - naive counter method, and sum of scores. Results are actually quite fantastic from a human use perspective.

```
Enter Statement to Classify (q to exit):
It’s also heartbreaking to see talented actors like Vikrant Massey and Yami Gautam weighed down by an average script.
....
{'0': 0.5116012503871078, '4': 0.4883987496128922}
Enter Statement to Classify (q to exit):
Both of them perform sincerely and they’re the only reason the film isn’t a complete write off.
....
{'0': 0.4074789098911728, '4': 0.5925210901088273}
```

 In this million data set `0` is negative sentiment, `4` is positive sentiment.

### Cross Testing : Train Generic - Test Specific

We have trained with the 1.4 million data - and test it against ( pretty crazily ) against the airlines twitter dataset which is massively biased towards negative: `"label_densities": {"positive": 0.16, "negative": 0.63, "neutral": 0.21}`.

The file is `cross_test.py`.

Turns out, the naive classification - w/o any special correction for check `max{}` is 75% accurate with `limit:10` !
Further   `grep False out.txt | grep '0.5' | grep 'positive' | wc -l`  has shown that additional 8% is labelled wrong because of bias - in case 50/50 - because it is negatively biased, it should be put to positive bucket to counter it.  That will increase the accuracy to `75+8 = 83%`.
By changing the `limit:15` one can increase the accuracy to `80%`.

### Self Testing : Testing against it's own Data

Given the system does not learn - any specifics about labelling at all, one can use it over itself to check
if the algorithm can predict it's own data. This should be reasonably high.
Turns out it is, with the following formula for `int( ceil( num_of_labels ) * 1.5))`
The accuracy of the prediction using `weighted_score` algorithm goes to `94%`.

The corresponding self-test file is `self_test.py`.

### Further Improvements

Can it be made to be more accurate? It can be by adding appropriate check and balanced (read `if else`) which are termed as `gate`s. Does it make sense?

**No**.

Take for example the benchmark ran on top of the https://pypi.org/project/textblob/ project.
This is available in the file `extern_tests.py`. The accuracy of the system is close to `16%`.

 It is now becoming a well known phenomenon that the algorithm perform very heavily in the toy-testing domain. But in real world they crack up. This was already predicted in another paper - https://arxiv.org/abs/1407.7417  .

Another analysis of the same ( treating sentiment as sentiment ) produced close to 60% accuracy.

https://towardsdatascience.com/fine-grained-sentiment-analysis-in-python-part-1-2697bb111ed4

With more than 80% accuracy, these algorithms are already at the top.

The trick is just label sentiment as another label.

The real competition of ML is not against the accuracy in absolute terms - but against a population of human workers trying to classify.

## Caution

This is a toy to showcase that there are way too many ways to foundational thinking about the discipline of AI.
Authors fully understand it - and is mentioned clearly in the paper. There are of course better class of algorithms available to do 2 classification,
but for multi-label classification and as an incredibly easy approach - nothing is simpler.


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

### Description

The LHA.sys driver before 1.1.1811.2101 in LG Device Manager exposes functionality that allows low-privileged users to read and write arbitrary physical memory via specially crafted IOCTL requests and elevate system privileges. This occurs because the device object has an associated symbolic link and an open DACL.

### POC

#### Reference
- http://www.jackson-t.ca/lg-driver-lpe.html

#### Github
- https://github.com/0xcyberpj/windows-exploitation
- https://github.com/0xpetros/windows-privilage-escalation
- https://github.com/474172261/KDU
- https://github.com/ARPSyndicate/cvemon
- https://github.com/FULLSHADE/WindowsExploitationResources
- https://github.com/NitroA/windowsexpoitationresources
- https://github.com/NullArray/WinKernel-Resources
- https://github.com/Ondrik8/exploit
- https://github.com/TamilHackz/windows-exploitation
- https://github.com/emtuls/Awesome-Cyber-Security-List
- https://github.com/h4rmy/KDU
- https://github.com/hfiref0x/KDU
- https://github.com/sl4v3k/KDU

repository: trickest/cve

repo_name: trickest/cve


text:
# gradle-example

This is an example Gradle project that builds an executable Java application using the "application" plugin.
It can be used to try out various Gradle features for Java development, such as:

* Running the application (`gradle run`)
* Testing it (`gradle test`)
  * By default, you will only see any output about testing if tests fail.
  * `gradle test` automatically generates a HTML report about all tests, see `build/reports/tests/index.html`.
* Making a distributable version of it (`gradle installDist` - output is in `build/install`)
  * You can also use `distZip` or `disTar` to create a ZIP or Tar archive of `installDist`'s output under `build/distributions`.
* Generating Javadocs (`gradle javadoc` - output is in `build/docs`)
* Clean the build directory (`gradle clean` - deletes the `build` folder)

## Running Gradle
This project includes a [Gradle Wrapper](https://docs.gradle.org/current/userguide/gradle_wrapper.html) so you don't need to download and install Gradle yourself. To use this wrapper, replace "gradle" with "gradlew" when running tasks, e.g. `gradlew javadoc`. It will automatically download Gradle for use with the current project.

If you're on Windows:
  * Start up a command prompt and browse to this directory
    * Tip: You can also hold shift and right click in this folder to get an option to do this
  * Run a Gradle task like this: `gradlew task`, where "task" is the task you want to run (e.g. "run")

If you're on Mac OS X or Linux:
  * Open a new terminal and browse to this directory
  * Run a Gradle task like this: `./gradlew task`, where "task" is the task you want to run

repository: einekatze/gradle-example

repo_name: einekatze/gradle-example


text:
# Secure application with TLS 1.2 (RFC 5246)
Here is a guide to deploying a web application served over TLS with a [GopherSauce](http://gophersauce.com) project.

## Requirements
1. GopherSauce project. (Make the project root your terminal's working directory)
2. HTTPS certificate & Key to use with application.

### Step 0
You can skip this step if you already have HTTPS certificate and key files. Read the part of this [Gist](https://gist.github.com/denji/12b3a568f092ab951456) to quickly (in my opinion) generate HTTPS certificate and key files.
### Step 1
Update your`gos.gxml` root XML tag (AKA `<gos>`) . Add attribute `https-cert` with value specifying a path to your certificate file.

### Step 2
Update your`gos.gxml` root XML tag (AKA `<gos>`) . Add attribute `https-key` with value specifying a path to your key file.

### Step 3
Update your`gos.gxml` port tag. Change it to `443`.

### Step 4
Run your project with TLS with the following command :

	gos --run


text:
# Restdocs Spec Generation Support

[![Build Status](https://github.com/BerkleyTechnologyServices/restdocs-spec/workflows/CI/badge.svg?branch=master&event=push)](https://github.com/BerkleyTechnologyServices/restdocs-spec/actions?query=branch%3Amaster+workflow%3ACI)
[![Maven Central](https://img.shields.io/maven-central/v/io.github.berkleytechnologyservices/restdocs-spec)](https://central.sonatype.com/search?q=a%253Arestdocs-spec%2520g%253Aio.github.berkleytechnologyservices&namespace=io.github.berkleytechnologyservices)

## Usage

First head over to the [ePages-de/restdocs-api-spec](https://github.com/ePages-de/restdocs-api-spec) project
and follow the instructions for setting up the Spring REST Docs extension.  That extension will produce
`resource.json` files for each of your documented resources.  You'll also notice that project provides
a gradle plugin that can be used to read all the `resource.json` files and turn them into an OpenAPI spec
file.  That is exactly what this project does as well, only in the form of a maven plugin instead.

Here is a typical `pom.xml` configuration:

```xml
  <plugin>
    <groupId>io.github.berkleytechnologyservices</groupId>
    <artifactId>restdocs-spec-maven-plugin</artifactId>
    <version>${restdocs-spec.version}</version>
    <executions>
      <execution>
        <goals>
          <goal>generate</goal>
        </goals>
      </execution>
    </executions>
  </plugin>
```

That will read your `resource.json` snippet files found under the `${project.build.directory}/generated-snippets`
directory and produce an OpenAPI 2.0 YAML file at `${project.build.directory}/restdocs-spec/openapi-2.0.yml`.

If you would prefer that the OpenAPI 2.0 document is in JSON format you can specify it like this:

```xml
  <plugin>
    <groupId>io.github.berkleytechnologyservices</groupId>
    <artifactId>restdocs-spec-maven-plugin</artifactId>
    <version>${restdocs-spec.version}</version>
    <executions>
      <execution>
        <goals>
          <goal>generate</goal>
        </goals>
        <configuration>
          <format>JSON</format>
        </configuration>
      </execution>
    </executions>
  </plugin>
```

You can also generate OpenAPI 3.0 or Postman Collection specification. For instance, this would generate OpenAPI 3.0:
```xml
  <plugin>
    <groupId>io.github.berkleytechnologyservices</groupId>
    <artifactId>restdocs-spec-maven-plugin</artifactId>
    <version>${restdocs-spec.version}</version>
    <executions>
      <execution>
        <goals>
          <goal>generate</goal>
        </goals>
        <configuration>
          <specification>OPENAPI_V3</specification><!-- switch this to POSTMAN_COLLECTION for Postman Collection specs -->
        </configuration>
      </execution>
    </executions>
  </plugin>
```

Finally, you can also generate multiple formats at once using the more verbose syntax:
```xml
  <plugin>
    <groupId>io.github.berkleytechnologyservices</groupId>
    <artifactId>restdocs-spec-maven-plugin</artifactId>
    <version>${restdocs-spec.version}</version>
    <executions>
      <execution>
        <goals>
          <goal>generate</goal>
        </goals>
        <configuration>
          <specifications>
            <specification>
              <type>OPENAPI_V2</type>
            </specification>
            <specification>
              <type>OPENAPI_V3</type>
              <format>JSON</format>
            </specification>
            <specification>
              <type>POSTMAN_COLLECTION</type>
              <filename>my-api-collection</filename>
            </specification>
          </specifications>
        </configuration>
      </execution>
    </executions>
  </plugin>
```

There are several other aspects you can optionally configure.  Here is the full set of options with their default values:

```xml
  <plugin>
    <groupId>io.github.berkleytechnologyservices</groupId>
    <artifactId>restdocs-spec-maven-plugin</artifactId>
    <version>${restdocs-spec.version}</version>
    <executions>
      <execution>
        <goals>
          <goal>generate</goal>
        </goals>
        <configuration>
          <name>${project.artifactId}</name>
          <version>${project.version}</version>
          <host>localhost</host>
          <basePath></basePath>
          <schemes>
            <scheme>http</scheme>
          </schemes>
          <snippetsDirectory>${project.build.directory}/generated-snippets</snippetsDirectory>
          <specification>OPENAPI_V2</specification>
          <outputDirectory>${project.build.directory}/restdocs-spec</outputDirectory>
          <skip>false</skip>
          <format>YAML</format>
          <filename>openapi-2.0</filename>
          <separatePublicApi>false</separatePublicApi>
          <tags />
          <oauth2 />
        </configuration>
      </execution>
    </executions>
  </plugin>
```

### Tags

By default the plugin will not generate any tags.  You can optionally provide tags using the
 `<tags />` element.  Here is an example:

```xml
  <plugin>
    <groupId>io.github.berkleytechnologyservices</groupId>
    <artifactId>restdocs-spec-maven-plugin</artifactId>
    <version>${restdocs-spec.version}</version>
    <executions>
      <execution>
        <goals>
          <goal>generate</goal>
        </goals>
        <configuration>
          <tags>
            <tag>
              <name>pets</name>
              <description>Everything about your Pets</description>
            </tag>
            <tag>
              <name>store</name>
              <description>Access to Petstore orders</description>
            </tag>
          </tags>
        </configuration>
      </execution>
    </executions>
  </plugin>
```

### OAuth2 Configuration

By default the plugin will not generate any security information.  You can optionally provide
it using the `<oauth2 />` element.  Here is an example:

```xml
  <plugin>
    <groupId>io.github.berkleytechnologyservices</groupId>
    <artifactId>restdocs-spec-maven-plugin</artifactId>
    <version>${restdocs-spec.version}</version>
    <executions>
      <execution>
        <goals>
          <goal>generate</goal>
        </goals>
        <configuration>
          <oauth2>
            <tokenUrl>http://example.com/uaa/token</tokenUrl>
            <authorizationUrl>http://example.com/uaa/authorize</authorizationUrl>
            <flows>
              <flow>accessCode</flow>
              <flow>implicit</flow>
            </flows>
            <scopes>
              <scope>
                <name>read</name>
                <description>Access to read operations.</description>
              </scope>
              <scope>
                <name>write</name>
                <description>Access to write operations.</description>
              </scope>
            </scopes>
          </oauth2>
        </configuration>
      </execution>
    </executions>
  </plugin>
```

## Example

You can find a full example project here: https://github.com/BerkleyTechnologyServices/restdocs-spec-example

## Still in development

* Support for additional specification formats is currently in development.  We plan to add
  support for Postman Collections and RAML.

repository: BerkleyTechnologyServices/restdocs-spec

repo_name: BerkleyTechnologyServices/restdocs-spec


text:
# 3D atherosclerotic plaque distribution and composition
Plaque analysis in 3D aorta imaging

### Plaque prediction

The script to train/fine-tune a model is `plaque_prediction/train_unet.py`. It takes as input an npz file containing training and validation set in the following sequence: train images, train labels, validation images, validation labels. The images should be normalized and the dimensions of images/labels are number_of_images, width, height, channels. We used (x,608,480,1). To test the script the data set provided in data/plaque_data_small.npz can be used (since this is only an example change lines 125 and 126 to arr_0 and arr_1 in train_unet.py).

The notebook `plaque_prediction/predict_plaque.ipynb` shows how to use a trained model to predict plaque.

### Anatomy segmentation

The script to train the 3D segmentation model is provided in `anatomy_segmentation/train_unet_3d.py`. The required input is a directory containing the training examples (aortas) and atlases of anatomy labels. Aortas and atlases are saved in the dimensions 300x260x190 pixels in nii.gz format (to process with sitk). Aorta lumen is filled in and the whole aorta is represented as binary image. Atlases contain labels 0-6 (0=background, 1=desc, 2=arch, 3=lsa, 4=lcca, 5=bca, 6=other). An example of an aorta and atlas are given in the data folder to test the code.

The notebook `anatomy_segmentation/anatomy_prediction.ipynb` gives an example on how to use a trained network to predict the anatomical structures in the aorta. It also shows the critical step of how to post-process the network predictions.

The weights of a trained 3D U-net are available [here](https://drive.google.com/file/d/1we2AUBz2tsk52HQd29v6Ue1CZEe8eGEi/view?usp=sharing)
### Used library versions
* python 3.6.8
* numpy 1.16.3
* tensorflow 1.13.1
* keras 2.2.4
* pillow 6.0.0
* SimpleITK 1.2.4
* scikit-image 0.17.dev0
* scipy 1.2.1
* Augmentor 0.2.3

The U-net implementation is inspired by [this repository](https://github.com/shibuiwilliam/Keras_Autoencoder).

When using this code, please cite: [https://www.nature.com/articles/s41598-020-78632-4](https://www.nature.com/articles/s41598-020-78632-4)


text:
# jr/passwords

[![Build Status](https://travis-ci.org/rebendajirijr/passwords.svg?branch=master)](https://travis-ci.org/rebendajirijr/passwords)
[![SensioLabs Insight](https://img.shields.io/sensiolabs/i/69334c36-e0b6-430f-8992-ae415d783518.svg)](https://insight.sensiolabs.com/projects/69334c36-e0b6-430f-8992-ae415d783518)
[![Installs](https://img.shields.io/packagist/dt/jr/passwords.svg)](https://packagist.org/packages/jr/passwords)
[![License](https://img.shields.io/packagist/l/jr/passwords.svg)](https://packagist.org/packages/jr/passwords)

Lightweight Nette-powered password generation and hashing.

## Installation

The best way to install jr/passwords is using the [Composer](http://getcomposer.org/):

```sh
$ composer require jr/passwords
```

## Documentation

Learn more in the [documentation](https://github.com/rebendajirijr/passwords/blob/master/docs/en/index.md).

repository: rebendajirijr/passwords

repo_name: rebendajirijr/passwords


text:
---
title: About
---

# lyp - The Lilypond Swiss Army Knife

Easily manage multiple versions of [Lilypond](http://lilypond.org/), install packages with support code and fonts, improve your score-preparation workflow and even improve lilypond's performance!

__Code reuse__: lyp lets you install [packages] that act as Lilypond code libraries and can be used to enhance your Lilypond files with additional functionality. Packages can depend on other packages. Lyp resolves both direct and transitive package dependencies, and automatically selects the correct version to use for each package.

__No hassle Lilypond installation__: With lyp you can also install any version of Lilypond on your machine with a single command, without having to visit the Lilypond website, clicking a link and then copying files around. In addition, lyp lets you switch between multiple versions of Lilypond and always keep your machine up to date with the latest version.

__Tools for power users__: with lyp you can [benchmark](documentation#lyp-benchmark) and compare the performance of multiple versions of Lilypond, [flatten](#lyp-flatten) include files, automatically recompile [modified source files](#lyp-watch), and [automatically install](#lyp-compile) package dependencies or any required version of Lilypond.

repository: andrewcsmith/lyp

repo_name: andrewcsmith/lyp


text:
# Changelog

All notable changes to this project will be documented in this file.

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

## [Unreleased]

## [1.0.2] - 2021.06.10

### Fixed

- Launch containers with GPUs and more shared memory when launching a container development environment.
- Install Git in the image.

## [1.0.1] - 2021.06.09

### Added

- Requirements to README.
- Print device (cuda or cpu) in use in MNIST example script.

### Changed

- Change to official PyTorch docker image.

### Fixed

- `docker run` command in the deployment sections of the READMEs.
- DVC checkpoints, data, models, and metrics directories not being automatically created.

## [1.0.0] - 2021.06.06

### Added

- Initial release.

repository: adamtupper/cookiecutter-lvsn-workflow

repo_name: adamtupper/cookiecutter-lvsn-workflow


text:
---
author:
- name: First Name
  affiliation: One University
  email<EMAIL_ADDRESS>- name: Second Name
  affiliation: Another University
  email<EMAIL_ADDRESS>institution: Foobar Institute
date: 'July 17, 2006'
title: Pandoc Test Suite
misc:
- item 1
- item 2
jel: [G21, D12, D62]
abstract: |
    Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
format:
  cmdline: see if double dash creates a bug # 'cls & remark 0*.md --view --output=cc2'
  show-titlepage: true
  show-published: true
  elegant-title: true
  thin-margins: true
  show-frame: false
  show-media: true
  media-in-back: false # true
  media-pagebreak: true
...

This is a set of tests for pandoc. Most of them are adapted from John Gruber’s
markdown test suite.

As the authors said [such as @foo;@bar], and [@foo]

  Right     Left     Center     Default
-------     ------ ----------   -------
     12     12        12            12
    123     123       123          123
      1     1          1             1

Table:  Demonstration of simple table syntax.

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

Headers
=======

Level 2 with an [embedded link](/url)
-------------------------------------

### Level 3 with *emphasis*

#### Level 4

##### Level 5

Level 1
=======

Level 2 with *emphasis*
-----------------------

### Level 3

with no blank line

Level 2
-------

with no blank line

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

Paragraphs
==========

Here’s a regular paragraph.

In Markdown 1.0.0 and earlier. Version 8. This line turns into a list item.
Because a hard-wrapped line in the middle of a paragraph looked like a list
item.

Here’s one with a bullet. \* criminey.

There should be a hard line break\
here.

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

Block Quotes
============

E-mail style:

> This is a block quote. It is pretty short.

> Code in a block quote:
>
>     sub status {
>         print "working";
>     }
>
> A list:
>
> 1.  item one
> 2.  item two
>
> Nested block quotes:
>
> > nested
>
> > nested

This should not be a block quote: 2 > 1.

And a following paragraph.

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

Code Blocks
===========

Code:

    ---- (should be four hyphens)

    sub status {
        print "working";
    }

    this code block is indented by one tab

And:

        this code block is indented by two tabs

    These should not be escaped:  \$ \\ \> \[ \{

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

Lists
=====

Unordered
---------

Asterisks tight:

-   asterisk 1
-   asterisk 2
-   asterisk 3

Asterisks loose:

-   asterisk 1

-   asterisk 2

-   asterisk 3

Pluses tight:

-   Plus 1
-   Plus 2
-   Plus 3

Pluses loose:

-   Plus 1

-   Plus 2

-   Plus 3

Minuses tight:

-   Minus 1
-   Minus 2
-   Minus 3

Minuses loose:

-   Minus 1

-   Minus 2

-   Minus 3

Ordered
-------

Tight:

1.  First
2.  Second
3.  Third

and:

1.  One
2.  Two
3.  Three

Loose using tabs:

1.  First

2.  Second

3.  Third

and using spaces:

1.  One

2.  Two

3.  Three

Multiple paragraphs:

1.  Item 1, graf one.

    Item 1. graf two.

2.  Item 2.

3.  Item 3.

Nested
------

-   Tab
    -   Tab
        -   Tab

Here’s another:

1.  First
2.  Second:
    -   Fee
    -   Fie
    -   Foe

3.  Third

Same thing but with paragraphs:

1.  First

2.  Second:

    -   Fee
    -   Fie
    -   Foe

3.  Third

Tabs and spaces
---------------

-   this is a list item indented with tabs

-   this is a list item indented with spaces

    -   this is an example list item indented with tabs

    -   this is an example list item indented with spaces

Fancy list markers
------------------

(2) begins with 2
(3) and now 3

    with a continuation

    iv. sublist with roman numerals, starting with 4
    v.  more items
        (A) a subsublist
        (B) a subsublist

Nesting:

A.  Upper Alpha
    I.  Upper Roman.
        (6) Decimal start with 6
            c)  Lower alpha with paren

Autonumbering:

1.  Autonumber.
2.  More.
    1.  Nested.

Should not be a list item:

M.A. 2007

B. Williams

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

Definition Lists
================

Tight using spaces:

apple
:   red fruit

orange
:   orange fruit

banana
:   yellow fruit

Tight using tabs:

apple
:   red fruit

orange
:   orange fruit

banana
:   yellow fruit

Loose:

apple

:   red fruit

orange

:   orange fruit

banana

:   yellow fruit

Multiple blocks with italics:

*apple*

:   red fruit

    contains seeds, crisp, pleasant to taste

*orange*

:   orange fruit

        { orange code block }

    > orange block quote

Multiple definitions, tight:

apple
:   red fruit
:   computer

orange
:   orange fruit
:   bank

Multiple definitions, loose:

apple

:   red fruit

:   computer

orange

:   orange fruit

:   bank

Blank line after term, indented marker, alternate markers:

apple

:   red fruit

:   computer

orange

:   orange fruit

    1.  sublist
    2.  sublist

HTML Blocks
===========

Simple block on one line:

foo

And nested without indentation:

foo

bar

Interpreted markdown in a table:

This is *emphasized*

And this is **strong**

Here’s a simple block:

foo

This should be a code block, though:

        foo

As should this:

foo

Now, nested:

foo

This should just be an HTML comment:

Multiline:

Code block:

Just plain comment, with trailing spaces on the line:

Code:

Hr’s:

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

Inline Markup
=============

This is *emphasized*, and so *is this*.

This is **strong**, and so **is this**.

An *[emphasized link](/url)*.

***This is strong and em.***

So is ***this*** word.

***This is strong and em.***

So is ***this*** word.

This is code: `>`, `$`, `\`, `\$`, `<html>`.

~~This is *strikeout*.~~

Superscripts: a^bc^d a^*hello*^ a^hello there^.

Subscripts: H~2~O, H~23~O, H~many of them~O.

These should not be superscripts or subscripts, because of the unescaped
spaces: a\^b c\^d, a\~b c\~d.

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

Smart quotes, ellipses, dashes
==============================

“Hello,” said the spider. “‘Shelob’ is my name.”

‘A’, ‘B’, and ‘C’ are letters.

‘Oak,’ ‘elm,’ and ‘beech’ are names of trees. So is ‘pine.’

‘He said, “I want to go.”’ Were you alive in the 70’s?

Here is some quoted ‘`code`’ and a “[quoted
link](http://example.com/?foo=1&bar=2)”.

Some dashes: one—two — three—four — five.

Dashes between numbers: 5–7, 255–66, 1987–1999.

Ellipses…and…and….

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

LaTeX
=====

-   \cite[22-23]{smith.1899}
-   $2+2=4$
-   $x \in y$
-   $\alpha \wedge \omega$
-   $223$
-   $p$-Tree
-   Here’s some display math:
    $$\frac{d}{dx}f(x)=\lim_{h\to 0}\frac{f(x+h)-f(x)}{h}$$
-   Here’s one that has a line break in it: $\alpha + \omega \times x^2$.

These shouldn’t be math:

-   To get the famous equation, write `$e = mc^2$`.
-   \$22,000 is a *lot* of money. So is \$34,000. (It worked if “lot”
    is emphasized.)
-   Shoes (\$20) and socks (\$5).
-   Escaped `$`: \$73 *this should be emphasized* 23\$.

Here’s a LaTeX table:

\begin{tabular}{|l|l|}\hline
Animal & Number \\ \hline
Dog    & 2      \\
Cat    & 1      \\ \hline
\end{tabular}

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

Special Characters
==================

Here is some unicode:

-   I hat: Î
-   o umlaut: ö
-   section: §
-   set membership: ∈
-   copyright: ©

AT&T has an ampersand in their name.

AT&T is another way to write it.

This & that.

4 < 5.

6 > 5.

Backslash: \\

Backtick: \`

Asterisk: \*

Underscore: \_

Left brace: {

Right brace: }

Left bracket: \[

Right bracket: \]

Left paren: (

Right paren: )

Greater-than: >

Hash: \#

Period: .

Bang: !

Plus: +

Minus: -

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

Links
=====

Explicit
--------

Just a [URL](/url/).

[URL and title](/url/ "title").

[URL and title](/url/ "title preceded by two spaces").

[URL and title](/url/ "title preceded by a tab").

[URL and title](/url/ "title with "quotes" in it")

[URL and title](/url/ "title with single quotes")

[with\_underscore](/url/with_underscore)

[Email<EMAIL_ADDRESS>
[Empty]().

Reference
---------

Foo [bar](/url/).

Foo [bar](/url/).

Foo [bar](/url/).

With [embedded \[brackets\]](/url/).

[b](/url/) by itself should be a link.

Indented [once](/url).

Indented [twice](/url).

Indented [thrice](/url).

This should \[not\]\[\] be a link.

    [not]: /url

Foo [bar](/url/ "Title with "quotes" inside").

Foo [biz](/url/ "Title with "quote" inside").

With ampersands
---------------

Here’s a [link with an ampersand in the URL](http://example.com/?foo=1&bar=2).

Here’s a link with an amersand in the link text:
[AT&T](http://att.com/ "AT&T").

Here’s an [inline link](/script?foo=1&bar=2).

Here’s an [inline link in pointy braces](/script?foo=1&bar=2).

Autolinks
---------

With an ampersand: <http://example.com/?foo=1&bar=2>

-   In a list?
-   <http://example.com/>
-   It should.

An e-mail address<EMAIL_ADDRESS>
> Blockquoted: <http://example.com/>

Auto-links should not occur here: `<http://example.com/>`

    or here: <http://example.com/>

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

Images
======

From “Voyage dans la Lune” by Georges Melies (1902):

![lalune](lalune.jpg "Voyage dans la Lune")

Here is a movie ![movie](movie.jpg) icon.

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

Footnotes
=========

Here is a footnote reference,[^1] and another.[^2] This should *not* be a
footnote reference, because it contains a space.\[\^my note\] Here is an
inline note.[^3]

> Notes can go in quotes.[^4]

1.  And in list items.[^5]

This paragraph should not be part of the note, as it is not indented.

[^1]: Here is the footnote. It can go anywhere after the footnote reference.
    It need not be placed at the end of the document.

[^2]: Here’s the long note. This one contains multiple blocks.

    Subsequent blocks are indented to show that they belong to the footnote
    (as with list items).

          {  }

    If you want, you can indent every line, but you can also be lazy and just
    indent the first line of each block.

[^3]: This is *easier* to type. Inline notes may contain
    [links](http://google.com) and `]` verbatim characters, as well as
    \[bracketed text\].

[^4]: In quote.

[^5]: In list.

repository: sergiocorreia/panflute

repo_name: sergiocorreia/panflute


text:
# Assessing Issues More Specifically
## Relationships to Presets: Open Street Map

This past week I looked more closely at one of the issues that we went over last week, which I think Isabelle talked about.
[Adding Relationships to Presets -- Open Street Map](https://github.com/openstreetmap/iD/issues/5326).

I really liked the clarity of this issue and I spent most of my time trying to understand presets -- this issue linked to a lot of
other related issues that also had some really good examples for what the collaborators are looking for.
Click [here](https://github.com/openstreetmap/iD/issues/4139) for some examples of good preset relationships.

I forked the iD repository so that I can start working on it -- the issue suggested that it might be good to establish rankings for preset relationships, which could help distinguish stronger versus weaker relationships between presets. So far I have not contributed
anything substantial because I am having a little bit of trouble with the JavaScript syntax, but I am working on potential rankings
that could be added.

For testing, I made some simple changes to this file [hospital](https://github.com/fasinha/iD/blob/master/data/presets/presets/amenity/hospital.json). Essentially, I modified the "related terms"
section, by adding terms like "medicine" and "medication" in order to further specify the nature of the hospital.

repository: nyu-hfoss-project/fasinha-blog

gha_language: CSS

repo_name: nyu-hfoss-project/fasinha-blog


text:
---
layout: post
title: "Exponential Climate Action by Diverse Actors is key"
date: 2022-04-22
description:
image: /assets/images/ipcc2022.jpeg
author: Avit K. Bhowmik
tags:
  - Climate Action
  - Exponential Climate Action
  - Transformation
---

What's new in the recent IPCC Report of working group III about climate mitigation? I would say, in a word, "everything"! Read Sol Agin and my comments on the report at [Karlstad University website](https://www.kau.se/en/news/exponential-climate-action-by-diverse-actors-key).

A few brief points to cover below:

- For the very first time, IPCC has extensively and explicitly highlighted the role of distributed Climate Action by diverse subnational actors. "Common but differentiated responsibilities" were the foundation of United Nations Framework Convention on Climate Change (UNFCCC) but the responsibility was effectively left on the hand of the nation states, as Nationally Determined Contribution (NDC) is the only metric we have for tracking the progress. This time, starting at the very first page, IPCC urges to go subnational, although indeed, nation states remain as an important actor.

- In 2020, colleagues and I have shown #communities comprising 10,000 people as the [Climate Action Sweet Spot](https://doi.org/10.1088/1748-9326/ab9ed0). We see evidences of this now in the success of many community and city led projects such Fridays for Future and C40 Cities.

- We need exponential climate action and social tipping points, time for incremental action is over! See [here](https://exponentialroadmap.org) to find out more.

repository: AvitBhowmik/avitbhowmik

branch_name: refs/heads/gh-pages

gha_language: SCSS

repo_name: AvitBhowmik/avitbhowmik


text:
[![Author](https://img.shields.io/badge/author-%40sgrame-blue.svg?style=flat-square)](https://twitter.com/sgrame)
[![License - MIT](https://img.shields.io/badge/license-MIT-blue.svg?style=flat-square)](http://opensource.org/licenses/MIT)

# .bash_profiles

This folder contains scripts and settings that will be loaded when you open a terminal.

The scripts and settings were created for use within an OSX environment.

## Installation
[Download](https://github.com/zero2one/bash_profiles/archive/develop.zip), unpack and move the folder to `/Users/<your username>` rename the folder to `.bash_profiles` so it becomes a hidden folder.

Or [clone](https://github.com/zero2one/bash_profiles) this repository within your home folder (`/Users/<your username>`).

```
$ git clone https://github.com/zero2one/bash_profiles.git ~/.bash_profiles
```

Replace the `.bash_profile` file within your home folder (`/Users/<your username>/.bash_profile`) by removing the original file and replace it with a symlink to the `bash_profile.sh` script in the `.bash_profiles` folder.

```
$ mv ~/.bash_profile ~/.bash_profile.BAK
$ ln -s ~/.bash_profiles/bash_profile.sh ~/.bash_profile
```

Close and reopen the terminal window or reload the `.bash_profile` by running the following command:

```
$ source ~/.bash_profile
```

## Enable scripts

This package has a set of predefined scripts. They are not defined by default.
You can enable them by creating a symlink from the `.bash_profiles/enabled/` folder to the script in the `.bash_profiles/available/` folder:

```
$ cd ~/.bash_profiles/enabled
$ ln -s ../available/<script name>.sh
```

You need to reload the .bash_profile folder (or close and reopen the terminal) to get the changes applied:

```
$ source ~/.bash_profile
```

The `.bash_profile` script will be loaded and will scan the enabled folder to load all `*.sh` files.

## Add aliases

The `.bash_profile` script will also load automatically all scripts in the `.bash_profiles/aliases` folder.

This folder is meant to hold scripts that define aliases, but you can put here whatever script you like to be loaded in the command line interface.

Make sure that each script starts with a shebang line (`#!/bin/bash`)

## Script included in the package

The `.bash_profiles/available`folder contains a set of predefined scripts.
See [Enable scripts](#enable-scripts) how to enable them.

This is an overview of all available scripts:

### bash_history.sh
Override the default `history` command settings for keeping and showing the bash history.

It will keep the last 100 000 commands you run trough CLI.

### composer.sh
Add the composer bin directory to the $PATH variable so packages installed globally by composer can be run without using the full path (e.g. phpunit, …).

### drupal_coder.sh

Run php code sniffer specific for Drupal.

**Usage:**

```
$ phpcsd /path/to/file_or_folder to check.
```

**The command will:**

* Use the Drupal standard.
* Show progress.
* Output the results in color.
* Exclude files that are generated by features.

**NOTE**: You need to have the coder package installed & configured using composer:

```
$ composer global require drupal/coder
$ phpcs --config-set installed_paths ~/.composer/vendor/drupal/coder/coder_sniffer
```

### git.sh
**Support for latest git version.**

X-Code comes with an outdated version of GIT.
Replace it with a manual updated version.

1. Download the latest version from http://git-scm.com/download/mac
2. Run the installer.

This script will adds the manual installed GIT bin path to the $PATH variable.

**Cleaner Git log output**

Alias to have a nicer log output from GIT.
See [https://coderwall.com/p/euwpig/a-better-git-log](https://coderwall.com/p/euwpig/a-better-git-log)

Use following command to see the nicer output:

```
$ git lg
```

### homebrew.sh
Brew autocomplete (including support for git).

You need to have following installation done:

1. Install [homebrew](http://brew.sh/).
2. Install autocomplete support for the `brew` and `git` commands:

   ```
   $ brew install git bash-completion
   ```

   (Note: If this install fails with a 404 error, and you already have git installed, just remove the git part of this brew install).

   ```
   $ brew install bash-completion
   ```

### java.sh
Force starting java jar files from cli in the background (e.g. Tomcat, Solr, Tika).

### mongodb.sh
Adds the MongoDB bin directory to the $PATH variable.

### mysql.sh
Add the bin directory, of the manually installed [MySQL server](http://dev.mysql.com/downloads/mysql/), to the $PATH variable.

### php_debug.sh
Enable/Disable debugging of PHP scripts when they are run in command line.
Use an IDE (like PhpStorm) that support PHP debugging.

Enable debugger by running:

```
$ php-debug-on
```

Disable debugger by running:

```
$ php-debug-off
```

### prompt.sh
Pimp the command prompt by:

* Add colors to it.
* Add extra info to it like current user, hostname & full path
* Put the prompt on 2 lines: 1 with the info, 2dn to enter command.
* Show the current GIT branch name (if any).

![bash_prompt](https://cloud.githubusercontent.com/assets/133124/6603845/d083629e-c824-11e4-8bce-0a74b086555f.png)

### tar.sh
Exclude OSX hidden files, created due to the extended attributes, from tarballs.

### terminal_window.sh
Add the current path to the terminal window & tab.

This will lookup the current path, create a shorter version out of it and add it as title to the terminal window & tab.

![terminal_window](https://cloud.githubusercontent.com/assets/133124/6603897/1d661336-c825-11e4-8420-ae845fcaf11f.png)

branch_name: refs/heads/develop

gha_language: Shell


text:
---
code: MA 277
title: Nonlinear Dynamical Systems and Chaos
books:
  - author:  Lichtenberg, A. J. and Lieberman, M. A.
    title: Regular and Stochastic motion
    publ: Springer-Verlag, 1983
  - author:  Guckenheimer, J. and Holmes, P.
    title: Nonlinear Oscillations, Dynamical Systems and bifurcations of vector fields
    publ: Springer-Verlag, 1983
ug-prereq-courses:
---

__Conservative Systems:__ Hamiltonians, canonical transformations, nonlinear
pendulum, perturbative methods, standard map, Lyapunov exponents, chaos, KAM
theorem, Chirikov criterion.

__Dissipative Systems:__ logistics map, period doubling, chaos, strange attractors,
fractal dimensions, Smale horseshoe, coupled maps, synchronization, control of
chaos.

repository: siddhartha-gadgil/DeptWeb

repo_name: siddhartha-gadgil/DeptWeb