text:
# Tideland Go Library

## 2017-01-18

- *audit.Generator* now provides *OneDurationOf()*
  and *SleepOneOf()*

## 2017-01-13

- *collections.RingBuffer* now provides *Peek()*

## 2017-01-07

- *etc.Etc* now can write to an *io.Reader*

## 2016-12-11

- Added asserts for *range*, *case*, and *path exists*

## 2016-12-07

- Added *ValidationAssertion* to *audit*

## 2016-11-23

- Fixed an error in *identifier* generation

## 2016-11-22

- Added *Name()* to *Generator* in *audit*

## 2016-11-15

- Added *Parse()* and *Compare()* to *version*
- Added package *library* for functions representing the whole
  Go Library; currently only containing *Version()*
- Extended *etc* to retrieve values out of environment variables

## 2016-11-01

- Added *SetLevelString()* to *logger* for setting the level
  out of readable configuration data
- Fixed a build problem on Windows for *logger*

## 2016-10-19

- *stringex* package now nows a simple *StringValuer*
- *configuration* and *web* are now removed

## 2016-10-14

- Backend in *monitoring* is now lazy loading
- Fixed splitting bug in *etc*

## 2016-10-13

- *Etc* now can handle templates substituted with values from other
  configuration variables or defaults

## 2016-10-07

- Added context handling to *etc* package
- Added *HasPath()* to *Etc*
- Added *DoAllDeep()* to the missing tree types in *collections*

## 2016-10-06

- Added *DoAllDeep()* to *KeyStringValueTree* in *collections* package
- Other tree types will follow later
- Added *Dump()* to *Etc*

## 2016-10-04

- Added *SplitFilter()* and *SplitMap()* to *stringex* for convenient splitting
  operations
- *Etc.Apply()* is now more robust by using *SplitMap()*

## 2016-10-03

- Added *Root()* to the trees in *collections*

## 2016-10-02

- *KeyValueTree* and *KeyStringValueTree* in *collections* now can copy subtrees
- Both now also support the retrieval and setting of keys
- Added *Split()* to *Etc*

## 2016-09-29

- Added *etc* based on former *configuration* package
- Marked *configuration* as deprecated
- Marked *web* as deprecated after migration to https://github.com/tideland/gorest

## 2016-02-16

- Removal of the *cells* package after migration to https://github.com/tideland/gocells

## 2015-09-01

- Added filtering to *logger* package

## 2015-08-23

- The backend of the *monitoring* package is now pluggable
- Beside the standard backend a null backend doing nothing has been added
- So last changes in *cells* packge have been rolled back as the monitoring
  handling is now a global topic

## 2015-08-18

- Monitoring in *cells* package is now pluggable

## 2015-08-17

- Fixed race condition in *cells* package
- Optimised time handling in *cells* package

## 2015-08-09

- Added `Collect()` and `DoAll()` to *errors* package

## 2015-08-02

- Added `BeginOf()` and `EndOf()` to *timex* package

## 2015-08-01

- Added `Set` and `StringSet` to *collections* package
- Added `Retry()` to *timex* package

## 2015-07-28

- Added assertion `Retry()` to *audit* package

## 2015-07-26

- Added `CallbackBehavior` to *cells* package

## 2015-07-24

- Fixed *cells* package unsubscribing failure when stopping cell with
  bi-directional subscriptions; thanks to Jonathan Camp for
  his fix
- Added expected value to compare with signal in `Wait()` assertion
- Added test for configuration validation in configurator behavior

## 2015-07-23

- Added `ReadFile()` to *configuration* package
- Added `SimpleProcessorBehavior` to *cells* package
- Added `ConfiguratorBehavior` to *cells* package
- Added assertion `Wait()` to *audit* package

## 2015-07-20

- Simplified *configuration* package for usage with `stringex.Defaulter`

## 2015-07-17

- Added *stringex* package

## 2015-07-10

- Added `KeyStringValueTreeBuilder` to *sml* package
- Several minor fixes

## 2015-07-05

- Made time format in *logger* package standard backend changeable

## 2015-06-28

- Changed *configuration* package to be more powerful
  and convenient

## 2015-06-25

- Added new `SceneBehavior` to *cells* package

## 2015-06-25

- Done migration into new library
- Added new *configuration* package

## 2015-06-05

- Started migration of existing packages into new library

repository: theckman/cronner

repo_name: theckman/cronner


text:
+++
City = "Toronto"
Year = "2016"
date = "2016-03-06T21:28:07-06:00"
type = "event"
title = "Sean Walberg"

+++

### Waterboy - our robot coworker

**Abstract:**

Waterboy is our Hubot instance that provides helpful information for both operations and developers. Our organization is somewhat atypical -- we are an external infrastructure consulting practice embedded into a development organization. This talk will cover:

+ How we introduced a chatbot into the organization
+ How we manage the robot and encourage people to contribute
+ How we figure out what goes into the robot
+ How we use ChatOps to facilitate communication between ourselves, and between us and the client.

People attending this talk will get a different perspective on the use of chat in a collaborative environment. It's not just shortcuts to memes, nor is it "hubot please go deploy the site and make me coffee". Chat can be a CLI to your organization. One that empowers employees and helps spread knowledge.

**Speaker:**

Sean Walberg, @seanwalberg

I'm a problem solver. A software developer that loves applying software principles to infrastructure automation and web applications.

I wanted to program most of my life, realized I didn't like it during my first job, spent 13 years as a network guy that wrote a lot of code, joined an awesome web startup as a web developer, and have rediscovered my joy for software development. After that ended, I moved into a more devops type role where I can have my feet in both camps. I'm currently with a consulting company that's responsible for the infrastructure and applications at a large American sporting league.

repository: vjanelle/devopsdays-web

path: /content/events/2016-toronto/proposals/Waterboy - our robot coworker.md

branch_name: refs/heads/master

extension: md

filename: Waterboy - our robot coworker.md

gha_language: HTML

gha_license_id: NOASSERTION

license_type: permissive

repo_name: vjanelle/devopsdays-web


text:
---
layout: post
title: July 2023 Blog Statistics
tags: [blog statistics]
keywords: [blog, statistics, blog statistics, analytics, pageviews, webmaster, webmaster tools, alexa, google]
hashtags: [blogging, blogstats]
image: /images/blog-stats/2023/07/search-console.webp
---

Another month, another blog stats post.

Not much was posted this month:

* [Ohio's Expanded EdChoice Program - A Breakdown of Scholarship Amounts for 2024](https://www.joehxblog.com/ohios-expanded-edchoice-program-a-breakdown-of-scholarship-amounts-for-2024/)
* [June 2023 Book Reading List](https://www.joehxblog.com/june-2023-book-reading-list/)

## Google Analytics

* Users → 6,200
* Views → 9,700

{% include image.html src="/images/blog-stats/2023/07/stats.webp" caption="Google Analytics Graph for July" %}

## Google Search Console

* Clicks → 5,430
* Search Impressions → 106,000
* Average position → 30.4

{% include image.html src="/images/blog-stats/2023/07/search-console.webp" caption="Google Search Console Graph for July" %}

## AdSense

* Balance → $68.28
* Estimated earnings → $39.50
* Impressions → 35,425
* Clicks → 124

{% include image.html src="/images/blog-stats/2023/07/adsense.webp" caption="Google AdSense Graph for July" %}

## Moz Stats

* Moz Domain Authority → 30
* Moz Linking Domains → 939

## Ratios

* Earnings / 1,000 users = $39.50 / 6.2 = $6.37
* Earnings / 1,000 views = $39.50 / 9.7 = $4.07
* Earnings / 1,000 impressions = $39.50 / 35,425 = $1.12
* Earnings / day = $39.50 / 30 = $1.32
* Users / day = 6,200 / 30 = 206.7
* Views / day = 9,700 / 30 = 323.3
* Impressions / day = 35,425 / 30 = 1,180.8

license: MIT

gha_license_id: MIT


text:
# Jenkins Pipeline - Working With Artifactory

## Introduction
The Pipeline Jenkins Plugin allows you to create a script that defines your build steps.
For those not familiar with Jenkins Pipeline, check out the [Pipeline Tutorial](https://github.com/jenkinsci/pipeline-plugin/blob/master/TUTORIAL.md) or the [Getting Started With Pipeline](https://jenkins.io/doc/pipeline/) documentation.

The Artifactory Pipeline DSL documentation is available [here](https://wiki.jenkins-ci.org/display/JENKINS/Artifactory+-+Working+With+Pipeline+Jobs+in+Jenkins).

## Examples
The examples below are meant to help you get started using the Artifactory DSL in your Pipeline scripts.
Follow the below steps to run the examples.

### Step 1 - Configure Artifactory Server for the Examples
All examples use an Artifactory server defined in Manage Jenkins, Configure System.
The server is retrieved by the examples as follows:
```
def server = Artifactory.server SERVER_ID
```
To set server ID for examples, follow these steps:
* Find or configure an Artifactory server in Jenkins through Manage Jenkins, Configure System.
* In the configuration of the Jenkins job that runs the example, check the *This project is parameterized* option.
* Click *Add Parameter* and then select *String Parameter*.
* Set the *Name* as *SERVER_ID* and the *Default Value* as the Artifactory Server ID configured in *Manage Jenkins*.

### Step 2 - Complete the Job Configuration

You can complete the job configuration by following one of the two methods described below.
#### Method 1:
In your Jenkins job configuration, set *Definition* to "Pipeline script",
and then copy the content of the example's Jenkinsfile into the *Script* text-area.
#### Method 2:
In your Jenkins job configuration, set the following:
* Set *Definition* to "Pipeline script from SCM".
* Set *SCM* to *Git*.
* Set *Repository URL* to *https://github.com/JFrogDev/project-examples.git*
* Set *Script Path* to the relative path to the example's Jenkinsfile. For example, for the below *props-example*, set *Script Path* to *jenkins-pipeline-examples/props-example/Jenkinsfile*

### Available Examples
Here are the available examples.
* The [props-example](https://github.com/jfrogdev/project-examples/tree/master/jenkins-pipeline-examples/props-example) downloads and uploads files to Artifactory with properties. The props-example also uses a placeholder when uploading.
* The [props-single-file-example](https://github.com/jfrogdev/project-examples/tree/master/jenkins-pipeline-examples/props-single-file-example) is the same as the [props-example](https://github.com/jfrogdev/project-examples/tree/master/jenkins-pipeline-examples/props-example), but has the specs embedded inside the Groovy script.
* The [promotion-example](https://github.com/jfrogdev/project-examples/tree/master/jenkins-pipeline-examples/promotion-example) demonstrates how to promote a build in Artifactory.
* The [vars-build-retention-example](https://github.com/jfrogdev/project-examples/tree/master/jenkins-pipeline-examples/vars-build-retention-example) demonstrates capturing environment variables and build retention in Artifactory.
* The [aql-example](https://github.com/jfrogdev/project-examples/tree/master/jenkins-pipeline-examples/aql-example) uses a Download Spec which includes [AQL](https://www.jfrog.com/confluence/display/RTF/Artifactory+Query+Language) instead of a wildcard pattern.
* The [maven-example](https://github.com/jfrogdev/project-examples/tree/master/jenkins-pipeline-examples/maven-example) resolves dependencies, deployes artifacts and publishes build-info to Artifactory for a Maven build.
* The [gradle-example-ci-server](https://github.com/jfrogdev/project-examples/tree/master/jenkins-pipeline-examples/gradle-example-ci-server) resolves dependencies, deployes artifacts and publishes build-info to Artifactory for a Gradle build. Unlike the [gradle-example](https://github.com/jfrogdev/project-examples/tree/master/jenkins-pipeline-examples/gradle-example), this examples assumes that the Gradle Artifactory Plugin in not applied to the Gradle build script.
* The [gradle-example](https://github.com/jfrogdev/project-examples/tree/master/jenkins-pipeline-examples/gradle-example) resolves dependencies, deployes artifacts and publishes build-info to Artifactory for a Gradle build. Unlike the [gradle-example-ci-server](https://github.com/jfrogdev/project-examples/tree/master/jenkins-pipeline-examples/gradle-example-ci-server), this examples assumes that the Gradle Artifactory Plugin in already applied in the Gradle build script.

repository: syryin/project-examples

repo_name: syryin/project-examples


text:
# tasker
A change-driven CLI task manager.

## Usage
On launch, `tasker` will present you with a special task and a prompt:

```
*0. inactive
Active task was started on ...
...
>>
```

This task will have it's cumulative hours seperated from the rest
of the user's tasks.

The asterisk indicates the currently activated task. At the prompt,
a user can enter

- The index of an existing task. This will switch that task to active
	and refresh all times.
- The name of a new task. This will create a new task and refresh times.
- Newline. This will refresh the times, leaving the currently activated task
	active. It is equivalent to entering the index of the active task.

repository: ClaytonMcCray/tasker

repo_name: ClaytonMcCray/tasker


text:
---
layout: post
title: Maria Kanata (Games)
description: The 7th Game
date: '2018-09-01T01:10:28+02:00'
image: /assets/images/nasiosa_g7_06.jpg
tags:
  - Games
author: Achilles Nasios
---
### The 7th Game -

_(June 2018)_

 I grew up in Amfissa in the Delphi area, in an atmosphere full of art with a father who was a painter, so it was almost inevitable to follow in his footsteps.

I studied sculpture and ceramics in Italy and worked for several years teaching art  at school. Photography has entered my life in recent years and I am passionate about it. Through it I try to capture my thoughts and get inspired  from my subject and the socio-political environment.

I attended photography seminars with Plato Rivellis, Costi Antoniadis, Eleni Mouzakitis and Lampros Papanikolatos. I have made 2 personal exhibitions of sculpture and have taken part in collaborative art and photo exhibitions.

![null](/assets/images/kanatam_g7_01.jpg)

![null](/assets/images/kanatam_g7_02.jpg)

![null](/assets/images/kanatam_g7_03.jpg)

![null](/assets/images/kanatam_g7_04.jpg)

![null](/assets/images/kanatam_g7_05.jpg)

![null](/assets/images/kanatam_g7_06.jpg)

![null](/assets/images/kanatam_g7_07.jpg)

![null](/assets/images/kanatam_g7_08.jpg)

![null](/assets/images/kanatam_g7_10.jpg)

![null](/assets/images/kanatam_g7_11.jpg)

![null](/assets/images/kanatam_g7_12.jpg)

repository: achillesn/photogames

repo_name: achillesn/photogames


text:
# RailsBuddy

RailsBuddy is a Rails engine that adds a web UI that can be used for running common Rails development tasks, like creating migrations and viewing routes. It's still a work-in-progress at this point.

## Installation
Add this line to your application's Gemfile:

```ruby
gem 'rails_buddy', group: :development
```

And then execute:
```bash
$ bundle
```

Then, just mount RailsBuddy in your `config/routes.rb` file:

```ruby
mount RailsBuddy::Engine => "/buddy"
```

Now, navigate to `http://localhost:3000/buddy`, and meet your new friend.

## Contributing
Contribution directions go here.

## License
The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).


text:
> Known Bug: Does not currently run on Windows.

# Mandatum

A simple Javascript stack that allows you to control the Ryze Tello drone from a desktop interface.

## Table of Contents

- [Mandatum](#mandatum)
  - [Table of Contents](#table-of-contents)
  - [Introduction](#introduction)
  - [Quick Start](#quick-start)
  - [Commands](#commands)
  - [Licence](#licence)

## Introduction

Mandatum is a Javascript stack that utilises VueJS and NodeJS to allow interaction with the Ryze Tello drone. The stack communicates with the drone via UDP messages.

## Quick Start

To get started, you will need to run `npm install` in the root directory. When that is done, you can launch the program via command line using `npm run electron:serve` or if you would like to build it, you need to run `npm run electron:build`.

## Commands

You can find all the available commands and their inputs [here](https://dl-cdn.ryzerobotics.com/downloads/tello/20180910/Tello%20SDK%20Documentation%20EN_1.3.pdf).

To execute a command, type into the command prompt and press `enter`.

## Licence

The MIT License (MIT)

Copyright (c) 2019 TokenChingy

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: TokenChingy/mandatum

gha_language: Vue

repo_name: TokenChingy/mandatum


text:
#### To contribute with this awesome project

- Fork the project
- Open an issue
- Make a new branch with the name of your new feature
- Add tests
- Run `gulp build` before commit and make the PR

Try to make micro commits for easy understanding of what you are doing.
To update docs site, make another PR on `gh-pages` branch with only content generated in `dist/doc` folder.
Please make sure that all tests are passing by `gulp test`. You can check all the tasks located on gulp folder for more details.

- Feel free to open issues if you run into a problem or if you just have suggestions. PR´s are always welcome.
[Changelog](https://github.com/stewones/angular-morris-chart/releases)


text:
---
layout: default
---

# 1993-12-24 - Happy Holidays

## Header Data

From<EMAIL_ADDRESS>(Harry Bartholomew)

To<EMAIL_ADDRESS>Message Hash: 89f42d65dfb6aa3371502549ae311dd5bbdee3fe588e9104687d99508ef9a039

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1993-12-24 09:46:11 UTC

Raw Date: Fri, 24 Dec 93 01:46:11 PST

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>(Harry Bartholomew)
Date: Fri, 24 Dec 93 01:46:11 PST
To<EMAIL_ADDRESS>Subject: Happy Holidays
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

    As one who reflexively deletes all of Larry's posts under whatever
    his name-of-the-moment may be, I sometimes wonder if I'm missing
    some gems hidden in the mass of text. I have presumed, and hope,
    that those still reading him, will share anything of value. :-)

{% endraw %}
```

## Thread

+ Return to [December 1993](/archive/1993/12)

+ Return to<EMAIL_ADDRESS>(Harry Bartholomew)](/authors/bart_at_netcom_com_harry_bartholomew_)"

+ 1993-12-24 (Fri, 24 Dec 93 01:46:11 PST) - Happy Holidays -<EMAIL_ADDRESS>(Harry Bartholomew)_


text:
# Drum-Classification-pytorch
## Drum Robot & Algorithm Overview

We propose a dataset containing both various drum sounds and multiple drum sounds combined (called the KIST-Drum database1). We extracted 187.5 ms length drum samples from music played only drums and converted them into images. It obtained 28,992 images and increased them to 63,735 images through augmentation. The 23 drum classes corresponding to each image were annotated by file name. To apply a model suitable for the performing robot system, five convolutional neural networks were used and ablation studies were performed by changing the type of input image and the presence of augmented images in the training set.

## KIST-DRUM Dataset

</>

We introduce data set of instrumental sample sounds of standard real drum.  Our target classes are bass drum (B), snare drum (S), closed hi-hat (CH), open hi-hat (OH), ride cymbal (R), floor tom (FT) and mid tom (MT). Additionally, we reserve more classes combined sound when beat simultaneously two or more instrument like bass drum and closed hi-hat (B+CH), bass drum and open hi-hat (B+OH), bass drum and ride cymbal (B+R), bass drum and floor tom (B+FT), bass drum and crash cymbal (B+C), snare and bass drum (S+B), snare drum and closed hi-hat (S+CH), snare drum and open hi-hat (S+OH), snare drum and ride cymbal (S+R), snare drum and floor tom (S+FT), snare drum and crash cymbal (S+C), mid and floor tom (MT+FT), snare and bass drum and closed hi-hat (S+B+CH), snare and bass drum and open hi-hat (S+B+OH), snare and bass drum and ride cymbal (S+B+R). There are total of 23 classes including ‘Rest’ when drums don’t onset.

## Download Drum Samples Dataset
You can download dataset from https://sites.google.com/d/1GQJ5W7wfv_i4ARKIYW7c0aV1KnIt2AVh/p/1RMVQLFuyCXoxI1UiTocWhxVn7UXWpavK/edit

or in Jupyter Notebook,

~~~
import gdown
google_path = 'https://drive.google.com/uc?id='
file_id = '1VsgbtqBhVnCDpXgp9ydW53eBkfDRq7Tf'
output_name = 'drumdataset.egg'
gdown.download(google_path+file_id,output_name,quiet=False)
~~~

## Dataset Overview
~~~
from data_augmentation_overview import Dataset_overview
data_overview = Dataset_overview(labels,data_version)
data_overview.overview()
~~~

## Ablation Test

Change input data type (Waveform, Mel-spectrogram, Wavefrom + Mel-spectrogram), presence or absence of augmentation, 5 networks (VGG19, ResNet32, EfficientNetB0, B1, B2).

## Confusion matrix of EfficientNet-B0 + Aug + Mel-spectrogram (TEST)

</>

Test dataset consisted of crop images extracted sequentially based on tempo from music played only with real drums not used in training and validation. Like the training set, the size of test dataset is 256x384 and have four channels.  Since the classes were extracted from songs, they differ in numbers, and there are relatively fewer classes, such as in S+B+R, B+FT, and MT+FT, which are mainly used as ornaments.

## Cite

repository: SoobumKim/Drum-Classification-pytorch

gha_language: Jupyter Notebook

repo_name: SoobumKim/Drum-Classification-pytorch


text:
URLNavigator
============

![Swift](https://img.shields.io/badge/Swift-2.1-orange.svg)
[![Build Status](https://travis-ci.org/devxoul/URLNavigator.svg)](https://travis-ci.org/devxoul/URLNavigator)
[![CocoaPods](http://img.shields.io/cocoapods/v/URLNavigator.svg)](https://cocoapods.org/pods/URLNavigator)
[![Carthage compatible](https://img.shields.io/badge/Carthage-compatible-4BC51D.svg?style=flat)](https://github.com/Carthage/Carthage)

⛵ URLNavigator provides an elegant way to navigate through view controllers by URLs. URL patterns can be mapped by using `URLNavigator.map(_:_:)` function.

URLNavigator can be used for mapping URL patterns with 2 kind of types: `URLNavigable` and `URLOpenHandler`. `URLNavigable` is a type which defines an custom initializer and `URLOpenHandler` is a closure which can be executed. Both an initializer and a closure receive an URL and placeholder values.

At a Glance
-----------

#### Mapping URL Patterns

URL patterns can contain placeholders. Placeholders will be replaced with matching values from URLs. Use `<` and `>` to make placeholders. Placeholders can have types: `string`(default), `int`, `float`, and `path`.

Here's an example of mapping URL patterns with view controllers and a closure. View controllers should conform a protocol `URLNavigable` to be mapped wisth URL patterns. See [Implementing URLNavigable](#implementing-urlnavigable) section for details.

```swift
Navigator.map("myapp://user/<int:id>", UserViewController.self)
Navigator.map("myapp://post/<title>", PostViewController.self)

Navigator.map("myapp://alert") { URL, values in
    print(URL.queryParameters["title"])
    print(URL.queryParameters["message"])
    return true
}
```

> **Note**: Global constant `Navigator` is a shortcut for `URLNavigator.defaultNavigator()`.

#### Pushing, Presenting and Opening URLs

URLNavigator can push and present view controllers and execute closures with URLs.

Provide the `from` parameter to `pushURL()` to specify the navigation controller which the new view controller will be pushed. Similarly, provide the `from` parameter to `presentURL()` to specify the view controller which the new view controller will be presented. If the `nil` is passed, which is a default value, current application's top most view controller will be used to push or present view controllers.

`presentURL()` takes an extra parameter: `wrap`. If `true` is specified, the new view controller will be wrapped with a `UINavigationController`. Default value is `false`.

```swift
Navigator.pushURL("myapp://user/123")
Navigator.presentURL("myapp://post/54321", wrap: true)

Navigator.openURL("myapp://alert?title=Hello&message=World")
```

For full documentation, see [URLNavigator Class Reference](http://cocoadocs.org/docsets/URLNavigator/0.6.0/Classes/URLNavigator.html).

#### Implementing URLNavigable

View controllers should conform a protocol `URLNavigable` to be mapped with URLs. A protocol `URLNavigable` defines an failable initializer with parameter: `URL` and `values`.

Parameter `URL` is an URL that is passed from `URLNavigator.pushURL()` and `URLNavigator.presentURL()`. Parameter `values` is a dictionary that contains URL placeholder keys and values.

```swift
final class UserViewController: UIViewController, URLNavigable {

    init(userID: Int) {
        super.init(nibName: nil, bundle: nil)
        // Initialize here...
    }

    convenience init?(URL: URLConvertible, values: [String : AnyObject]) {
        // Let's assume that the user id is required
        guard let userID = values["id"] as? Int else {
            return nil
        }
        self.init(userID: userID)
    }

    required init?(coder aDecoder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }

}
```

> **Note**: `URLConvertible` is a protocol that `NSURL` and `String` conforms.

Installation
------------

- **For iOS 8+ projects** with [CocoaPods](https://cocoapods.org):

    ```ruby
    pod 'URLNavigator', '~> 0.6'
    ```

- **For iOS 8+ projects** with [Carthage](https://github.com/Carthage/Carthage):

    ```
    github "devxoul/URLNavigator" ~> 0.6
    ```

- **For iOS 7 projects** with [CocoaSeeds](https://github.com/devxoul/CocoaSeeds):

    ```ruby
    github 'devxoul/URLNavigator', '0.6.0', :files => 'Sources/*.swift'
    ```

- **Using [Swift Package Manager](https://swift.org/package-manager)**:

    ```swift
    import PackageDescription

    let package = Package(
        name: "MyAwesomeApp",
        dependencies: [
            .Package(url: "https://github.com/devxoul/URLNavigator", "0.6.0"),
        ]
    )
    ```

Tips and Tricks
---------------

#### Where to Map URLs

I'd prefer using separated URL map file.

```swift
struct URLNavigationMap {

    static func initialize() {
        Navigator.map("myapp://user/<int:id>", UserViewController.self)
        Navigator.map("myapp://post/<title>", PostViewController.self)

        Navigator.map("myapp://alert") { URL, values in
            print(URL.parameters["title"])
            print(URL.parameters["message"])
            self.someUtilityMethod()
            return true
        }
    }

    private static func someUtilityMethod() {
        print("This method is really useful")
    }

}
```

Then call `initialize()` at `AppDelegate`'s `application:didFinishLaunchingWithOptions:`.

```swift
@UIApplicationMain
final class AppDelegate: UIResponder, UIApplicationDelegate {

    func application(application: UIApplication,
                     didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
        // Navigator
        URLNavigationMap.initialize()

        // Do something else...
    }
}
```

#### Implementing AppDelegate Launch Option URL

It's available to open your app with URLs if custom schemes are registered. In order to navigate to view controllers with URLs, you'll have to implement `application:didFinishLaunchingWithOptions:` method.

```swift
func application(application: UIApplication,
                 didFinishLaunchingWithOptions launchOptions: [NSObject: AnyObject]?) -> Bool {
    // ...

    if let URL = launchOptions?[UIApplicationLaunchOptionsURLKey] as? NSURL {
        self.window?.rootViewController = Navigator.viewControllerForURL(URL)
    }
    return true
}

```

#### Implementing AppDelegate Open URL Method

You'll might want to implement custom URL open handler. Here's an example of using URLNavigator with other URL open handlers.

```swift
func application(application: UIApplication,
                 openURL url: NSURL,
                 sourceApplication: String?,
                 annotation: AnyObject) -> Bool {
    // If you're using Facebook SDK
    let fb = FBSDKApplicationDelegate.sharedInstance()
    if fb.application(application, openURL: url, sourceApplication: sourceApplication, annotation: annotation) {
        return true
    }

    // URLNavigator Handler
    if Navigator.openURL(url) {
        return true
    }

    // URLNavigator View Controller
    if Navigator.presentURL(url, wrap: true) != nil {
        return true
    }

    return false
}
```

#### Using with Storyboard

It's not yet available to initialize view controllers from Storyboard. However, you can map the closures alternatively.

```swift
Navigator.map("myapp://post/<int:id>") { URL, values in
    guard let postID = values["id"] as? Int,
          let postViewController = UIStoryboard(name: "Main", bundle: nil).instantiateInitialViewController()
          else { return false }
    Navigator.push(postViewController)
    return true
}
```

Then use `Navigator.openURL()` instead of `Navigator.pushURL()`:

```swift
Navigator.openURL("myapp://post/12345")
```

#### Setting Default Scheme

Set `scheme` property on `URLNavigator` instance to get rid of schemes in every URLs.

```swift
Navigator.scheme = "myapp"
Navigator.map("/user/<int:id>", UserViewController.self)
Navigator.push("/user/10")
```

This is totally equivalent to:

```swift
Navigator.map("myapp://user/<int:id>", UserViewController.self)
Navigator.push("myapp://user/10")
```

Setting `scheme` property will not affect other URLs that already have schemes.

```swift
Navigator.scheme = "myapp"
Navigator.map("/user/<int:id>", UserViewController.self) // `myapp://user/<int:id>`
Navigator.map("http://<path>", MyWebViewController.self) // `http://<path>`
```

License
-------

URLNavigator is under MIT license. See the [LICENSE](LICENSE) file for more info.


text:
# An animation page to wish someone happy birthday or send as a gift 🎁

I made this for a friend to wish her happy birthday in a special way. It is reponsive and optimized for mobile devices.
Edit a few words to make it yours.

Download the files and click on the index.html file to view it in the browser.

URL: https://eladoh.github.io/happy-birthday/

Technology used:
 * HTML5, H5 canvas
 * CSS3, CSS animation
 * jQuery
 * Bootstrap 4

## Demo
I put this page together from various sources. Will explain in detail how each section is connected.

### Section 1

* The first section is a happy birthday greeting made of particles.
* Resolution is optimized for viewing on handphone.
* The particle is activated when touched.

* Position of each particle is updated in each frame. *A variable `count` is incremented by `1` when the postion of each particle is updated. It is used to control the timing of this section.*
* In each frame, a variable `vy` (randomly initiated for each particle) will be added to each particle's y-position and `vy` will also be added with a constant value. This makes the particles fall down the screen faster and faster.
* When a particle reaches the bottom of the screen, its `vy` is reset to an opposite sign and several times larger. The particle will thus bounce up and out of the screen.

* `vy` is always added with the constant value each frame, so when the particle fall down again to the screen, it will have a large `vy`. It thus falls down quickly.
* When `count` reaches 8000000, all particles are set to fall down with constant `vy`.
* When `count` variable reaches 9000000, all particles will be set to move away from the screen.
* When no particles are in the screen, the animation is terminated and next section will start.
* *The switching from section 1 to 2 depends on the movement of the particles, not on the lapse of time, making it more repsonsive to user's action.*

### Section 2

* This section is a giftbox with confetii in the background. When clicking the giftbox, words will pop up one sentence at a time.
* The words can be edited in the 2D array `strings_1` in `scripts/index.js`.
* Alignment of the words can be adjusted by adding space to the string. There will not be any extra fireworks or ballon on top of the space.

* After all the sentences are looped through, a bootstrap modal containing a video will pop up. You can use any video you like.
* The modal will be hidden and the video can be paused when clicking on the grey area.
* A reminder for this will be shown towards the end of the happy birthday video.

### Section 3

* When the modal is closed, the last section will be shown. It contains a banner which moves for a few cycles and a few buttons.
* The first one is used to call back the video modal and the section will be hidden until the modal is closed again.
* You can add other functions to these buttons if you wish.
* The animations for the banner and buttons are done using CSS animation.

### Other idea
Can use a customized domain name such as a.giftfor***.xyz when sending it to someone :)

Hope you like it! ❤

## acknowledgements

Feel free to use any part of this! Contributions are welcome,

Thanks to all copepen which I copied, use few parts of.


text:
# Landing Page Theme for Hugo

[Hugo](http://gohugo.io) theme based on the
[landing-page theme for Jekyll](https://github.com/swcool/landing-page-theme)

# How to use

## Background Images

Override the default intro and contact backgrounds by putting images in these files:

* `img/intro-bg.jpg`
* `img/contact-bg.jpg`

## About Section

Create a markdown file named `content/about/about.md`

```txt
---
Title: About Us
Draft: false
---

WidgetCo is the world leader in widget production.
```

## Services Section

Create a markdown file describing a service you offer in `content/services/` - e.g. `content/services/widgets.md`.

```txt
---
Title: Customized Widgets
Img: widgets.png
Category: Services
Draft: false
---

We specialize in bespoke widgets, built to your specification.
```

Then place a matching image in `static/img/services/` - e.g. `static/img/services/widgets.png`

## Pricing Section

![Pricing Section Screenshot](./images/Pricing_Section.png?raw=true "Pricing Section Screenshot")
Find example data in `exampleSite/data/pricing.json`
To enable the pricing section, create `content/pricing/pricing.md` with `draft: false` (or copy it from the exampleSite directory).

## Social Contact Buttons

Contact buttons will be automatically created if one or more
`[[params.social]]` is configured in `config.toml`:

```toml
baseurl = "http://yourdomain.com"
languageCode = "en-us"
title = "WidgetCo Inc"
[params]
	description = "The best widgets in the world!"

[[params.social]]
	title = "email"
	icon = "envelope-o"
	url =<EMAIL_ADDRESS>[[params.social]]
	title = "twitter"
	icon = "twitter"
	url = "https://twitter.com/SBootstrap"
[[params.social]]
	title = "github"
	icon = "github"
	url = "https://github.com/IronSummitMedia/startbootstrap"
[[params.social]]
	title = "linkedin"
	icon = "linkedin"
	url = "http://linkedin.com/yourusername"
```

* `title` parameter sets the text to be displayed on the contact button
* `icon` parameter sets which [Font Awesome icon](http://fortawesome.github.io/Font-Awesome/icons/)
will be displayed.

## Google Analytics

Google Analytics support is automatically enabled if you set the
`googleAnalytics` param in `config.toml` to your Google Analytics tracking ID.

```toml
[params]
googleAnalytics = "UA-12345678-1"

```

## Custom CSS

Add custom CSS by specifying file(s) using `custom_css` param e.g. files such as `static/css/local.css` and `static/css/media.css`

```toml
[params]
custom_css = ["css/local.css","css/media.css"]
```

# Demo
View this equivalent jekyll theme in action [here](https://swcool.github.io/landing-page-theme)

#Have a look, Have a try
```
git clone https://github.com/crakjie/landing-page-hugo.git
cd landing-page-hugo/exampleSite
hugo server -t landing-page-hugo
```
# Screenshot
![screenshot](https://raw.githubusercontent.com/swcool/landing-page-theme/master/img/screenshot.png)


text:
SublimeFiglet
=============

Add in Big ASCII Lettering direct from the Figlet [1] to Sublime Text [2].

How to Use
==========

You will need figlet installed on your system, e.g. on Ubuntu `sudo apt-get install figlet` or on Mac OS X `brew install figlet`.

This Package adds two commands to the command palette:

* `Figlet: Add Some ASCII Art Text` lets you type text and get the output of figlet.

* `Figlet: Select ASCII Art Font` lets you choose a font out of the installed ones.

        888'Y88 Y88b Y88     888   e88 88e   Y88b Y8P 888
        888 ,'Y  Y88b Y8     888  d888 888b   Y88b Y  888
        888C8   b Y88b Y     888 C8888 8888D   Y88b   "8"
        888 ",d 8b Y88b   e  88P  Y888 888P     888    e
        888,d88 88b Y88b "8",P'    "88 88"      888   "8"

License
=======

SublimeSuperMultiSelect is released under the MIT license.

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

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

 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.

[1]: http://www.figlet.org/
[2]: http://www.sublimetext.com/2

repository: sergeystoma/SublimeFiglet

repo_name: sergeystoma/SublimeFiglet


text:
+++
# Date this page was created.
date = 2018-11-10T00:00:00
layout = "project"

# Project title.
title = "3. Temperature and Precipitation Maps"

# Project summary to display on homepage.
summary = """
This project aimed to plot temperature and precipitation maps for North America using a remote server.
 """

image_preview = "img/featured.jpg"

# Tags: can be used for filtering projects.
# Example: `tags = ["Game Development", "Unreal"]`
tags = ["Data Visualization"]

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

# [header]
# image = "img/featured.jpg"

+++

# Overview
This is a data visualization project. My task is to plot temperature and precipitation maps for North America while given specific months and years (between 1960 -2014). All the data is stored in a csv file in a format similar to: <br>
![Test Scene 1](img/code.jpg)
For more information > https://github.com/info201b-wi2018/a6-remote-SiwenW1998

# Features
## I selected only observations for July 1960, July 1987, July 2014.

### July 1960
Air Temperature
![Test Scene 1](img/plot_1960_airtemp.jpg)
Precipitation
![Test Scene 1](img/plot_1960_precipitation.jpg)
### July 1987
Air Temperature
![Test Scene 1](img/plot_1987_airtemp.jpg)
Precipitation
![Test Scene 1](img/plot_1987_precipitation.jpg)
### July 2014
Air Temperature
![Test Scene 1](img/plot_2014_airtemp.jpg)
Precipitation
![Test Scene 1](img/plot_2014_precipitation.jpg)

path: /content/project/3. temperature and precipitation maps/index.md

gha_language: Shell


text:
---
jupyter:
  jupytext:
    formats: ipynb,md
    text_representation:
      extension: .md
      format_name: markdown
      format_version: '1.2'
      jupytext_version: 1.3.3
  kernelspec:
    display_name: crystal
    language: python
    name: crystal
---

# Data Ingest

The data is a key component of any machine learning algorithm.
The ingest of the data,
including the cleanup and labelling stages,
is often the most time consuming.
It requires taking the raw data,
in our case Molecular Dynamics trajectories, and
computing or extracting the quantities which will be used
for the Machine Learning.

In this example we will be using the relative orientations
of neighbouring molecules for our classification.
So by the end of this workbook we will have
a collection of data containing;

- the relative orientations of up to 6 nearest neighbours,
- the known classification, and
- temperature

## Imports

These are the packages required to run the notebook,
with the importing done to make the functions simple to use.
The detection module, is located in the directory `../src/`
which is why that directory needs to be added to
the list of directories python searches for modules.

```python
import numpy as np
from sdanalysis.figures import plot_frame
from sdanalysis.order import relative_orientations
import sklearn
import joblib
from crystal_analysis.detection import (
    read_file,
    read_all_files,
    classify_mols,
    plot_confusion_matrix,
    create_ml_ordering,
)
from crystal_analysis.figures import style_snapshot
from bokeh.io import export_svgs

# Show the configurations in the notebook
from bokeh.plotting import show, output_notebook

output_notebook()
```

## The input files

The input data for this tutorial is in the folder `../data/simulations/dataset/output`,
which contains a series of `.gsd` files.
This is the default file format of [Hoomd-blue](http://glotzerlab.engin.umich.edu/hoomd-blue/)
a molecular dynamics package designed to run on GPUs
from the Glotzer group at the University of Michigan.

To read these files we are going to use the [gsd](http://gsd.readthedocs.io/en/latest/) package
that the Glotzer group provide.
To read files from other simulation packages [MDAnalysis](https://www.mdanalysis.org/)
is a python package that will read nearly any file type.

This matches all the files in the directory
that start with `trajectory-Trimer-`,
reading the 100th configuration for each.
The 100th is chosen to ensure there are
thermal fluctuations of the positions.
This is limited by the speed of spontaneous melting
at high temperatures.

```python
directory = "../data/simulations/dataset/output"
input_files = read_all_files(directory, index=100, glob="trajectory-Trimer-*")
len(input_files)
```

The final line is a count of
the number of configurations which were found.
A check that I have found the files I am looking for.

### Labelling Data

To perform supervised classification of the data,
we need to provide labels for each local environment.
The configurations that I have prepared consist of two phases,
the middle 2/3 in the $x$ and $y$ directions is crystalline
while the remainder of the simulation cell is liquid.
This is probably easiest to understand using a picture;

```python
show(plot_frame(input_files[0].snapshot))
```

We can define molecules that have an $x$ position in the range
$
-L_x/3 < x < L_x/3
$
and have a $y$ position in the range
$
-L_y/3 < y < L_y/3
$
as being crystalline, with the crystal structure taken from the filename.
The remaining molecules can be classed as the generic liquid.
As before we can write a simple function
that takes a snapshot and the crystal structure,
returning the annotated classification of all molecules in the simulation.
At the interface of the two phases
the classification is not well defined,
so for the purposes of training and testing,
I am going to remove molecules within a distance of 3.5,
a bit over 1 neighbour shell,
to the boundary.

```python
crystals = [classify_mols(data.snapshot, data.crystal) for data in input_files]
```

### Compute training features

The final step is to compute the nearest neighbours for each of the molecules.
Most of the work of this function is done
using a function I wrote, `relative_orientations`.
This function uses the kdtree algorithm from scipy to compute the neighbours efficiently.
A side effect of using this function is that the neighbours are returned in order of increasing distance.
Then computes the relative orientation of the neighbour orientations using quaternion maths.

It should be noted that this the relative orientations function requires the orientations
to be expressed as quaternions.

The parameters to the relative_orientations function, `max_radius` and `max_neighbours`
are passed to the algorithm computing the neighbour lists.
`max_radius` defines the maximum distance to search for neighbours,
beyond this distance molecules are not considered neighbours.
The `max_neighbours` parameter defines the maximum number of neighbours to find.
Where there are more molecules within the `max_radius`
only the closest `max_neighbours` are returned.

```python
orientations = [
    relative_orientations(snap.box, snap.position, snap.orientation)
    for snap, *_ in input_files
]
```

## Loading the Data

Now with all the parts in place we can load all the data into a pandas DataFrame.
Taking the code we had at the start to read in all the snapshots,
we can now apply the functions we have just written,

- `get_sim_params`,
- `classify_mols`, and
- `compute_orientations`

to process the data into a succinct and usable form.

## Finding a Machine Learning Model

There are many different types of models we can use for classification,
each of these models have types of problems they are well suited to.
The goal of this notebook is to identify algorithms
that will effectively classify our dataset
which we can then investigate further.

### Collating the models

The first step here is creating a list of models we would like to test.
An excellent property of scikit-learn is
that all the algorithms have the same API,
allowing us to treat them all in the same way.

This is not an exhaustive list of all the possible classifiers in scikit-learn,
just a smattering for comparison.
For a more exhaustive list check out [the scikit-learn documentation](http://scikit-learn.org/stable/supervised_learning.html#supervised-learning),
and feel free to add more to the list.

```python
from sklearn import (
    linear_model,
    discriminant_analysis,
    tree,
    neighbors,
    naive_bayes,
    svm,
    neural_network,
)

ml_models = {
    "LR": linear_model.LogisticRegression(
        solver="lbfgs", multi_class="auto", max_iter=1000
    ),
    "LDA": discriminant_analysis.LinearDiscriminantAnalysis(),
    "DT": tree.DecisionTreeClassifier(),
    "KNN": neighbors.KNeighborsClassifier(),
    "NB": naive_bayes.GaussianNB(),
}
```

The Support-Vector Machine and the Neural Network classifiers
can also be included,
however they take significantly longer to run
and provide no increase in performance.

### Formatting the training data

Previously we loaded the data,
however we need it in a format
suitable for performing machine learning.
The format we want is;

- $X$, the input data (features) which is the orientation of the six nearest neighbours
- $y$, the true labelled classification of the data.

As part of this formatting,
we need to remove molecules which are 'unclassified',
that is the ones in the boundary
from both the features and the classification.
Here we are using concatenate
to combine the array for each configuration
into a single large array of all configurations.

```python
y = np.concatenate(crystals)
mask = y < 4
y = y[mask]
X = np.concatenate(orientations)[mask]
```

### Testing the Models

With a collection of models to test,
we now need some method of testing the models to compare them.
To perform the initial screening of datasets
we are going to break our training data into two groups,

- the training set, comprising 80% of the molecules
- the validation set, comprising the remaining 20%.

This division of the dataset gives us a set of data
previously unseen by the algorithms,
giving us a method of testing whether
the algorithm is actually learning the underlying features,
or just 'memorising' the training data.
This division of data will be through a random selection
so as not to bias the selection of data.

```python
validation_size = 0.20
seed = 7

selected = sklearn.model_selection.train_test_split(
    X, y, test_size=validation_size, random_state=seed
)
X_train, X_validation, y_train, y_validation = selected
```

To get an idea of the models which
warrant a further investigation,
we can iterate through each of our models.
Each model is scored by breaking the training data into `n_splits`,
using one of these splits for testing and
the remaining splits for training.
This process is referred to as *cross validation*
and typically the number of splits is 10.
For the purposes of this running in a reasonable amount of time,
`n_splits` is set to 2.

```python
scoring = "balanced_accuracy"
n_splits = 10

# Iterate through each model in our dictionary of models
for name, model in ml_models.items():
    kfold = sklearn.model_selection.KFold(n_splits=n_splits, random_state=seed)
    cv_results = sklearn.model_selection.cross_val_score(
        model, X_train, y_train, cv=kfold, scoring=scoring
    )
    print(f"{name:5s}: {cv_results.mean():.5f} ± {cv_results.std():.5f}")
```

Out of all the algorithms tested,
there are two that stand out

- K-Nearest Neighbours (KNN),
- Decision Tree (DT)

with accuracies in excess of 95%.

So with these three algorithms it is likely worth
tweaking the algorithms slightly from
the default parameters in an effort to improve performance.
It is also worth understanding which classes
each of these algorithms is strongest at classifying.
For this additional data we are going to be using a [confusion matrix](http://scikit-learn.org/stable/modules/generated/sklearn.metrics.confusion_matrix.html).
In a confusion matrix,
the diagonal elements represent the correct classifications,
while the off diagonal elements are the values
which were incorrectly classified.

Below we have a handy function from the scikit-learn documentation
that will nicely plot the confusion matrix as a heat map.

It is this point where our breaking the data into
training and validation sets becomes useful.
We can train a classifier using the training set,
then generate predictions of the validation dataset
using the known values of the validation data
to generate the confusion matrix.

```python
classes = ["liq", "p2", "p2gg", "pg"]
knn = ml_models["KNN"]
knn.fit(X_train, y_train)
predictions = knn.predict(X_validation)
plot_confusion_matrix(
    sklearn.metrics.confusion_matrix(y_validation, predictions, labels=range(4)),
    classes,
    normalize=True,
)
```

```python
predictions
```

## Testing Machine Learning

```python
selected_frames = [9, 2999, 1499]
crystals = ["p2", "p2gg", "pg"]
temperature = 0.45

knn_order = create_ml_ordering("../models/knn-trimer.pkl")

snaps = []
for index in selected_frames:
    for crystal in crystals:
        snap = read_file(
            index=index, temperature=temperature, pressure=1.0, crystal=crystal
        )
        plt = plot_frame(snap, knn_order)
        plt = style_snapshot(plt)
        plt.output_backend = "svg"
        export_svgs(plt, f"../figures/ml_demo_trimer_{crystal}_{index}.svg")
```

gha_language: Python


text:
# __TipTrackerApp__
## __Description__
A Full-Stack MERN application that allows users to create an account to track tips and other forms of income.
## __Table of Contents__
* [Dependencies](#dependencies)
* [Installation](#installation)
* [Usage](#usage)
* [Tests](#tests)
* [License](#license)
* [Badges](#badges)
* [GIF](#gif)
* [Screenshots](#screenshots)
* [Contributors](#contributors)
* [Contact Information](#questions)
* [Live Application](#application)
## __Dependencies__
    react / react-router-dom / graphQL / apollo-server-express / express / mongoose /
## __Tests__
    No tests provided.
## __Installation__
    npm i
## __Usage__

## __License__
__Copyright 2021__
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.
## __Badges__
[![License: MIT](https://img.shields.io/badge/License-MIT-hotpink.svg)](https://opensource.org/licenses/MIT)
## __GIF__
![Application Demo](client/public/tip-tracker-app.gif)

# __Screenshots__
![signin-ss](https://user-images.githubusercontent.com/56444674/129632457-09a273c6-b280-4a9d-b260-ec332b975fcf.png)
![register-ss](https://user-images.githubusercontent.com/56444674/129632460-c9a46af7-5b5d-4af8-90e8-881398977118.png)
![calendar-ss](https://user-images.githubusercontent.com/56444674/129632449-fbc8f3b8-a898-46b4-9998-51169f0d19c9.png)
![graph-ss](https://user-images.githubusercontent.com/56444674/129632453-cf0ec683-08c5-42a0-be51-a317dcfe0201.png)
![news-ss](https://user-images.githubusercontent.com/56444674/129632456-ba9452bb-a387-468f-bbe5-ea25847bf0ab.png)
![settings-ss](https://user-images.githubusercontent.com/56444674/129632452-5f0fa370-4049-49d4-983a-d3ca57742f02.png)
## __Contributors__
* Alex Bradshaw
* Mike DiSanto
* Heather Jackson
* Sam Sweigart
## __Questions__
If you would like to contribute to the project please contact one of the team members below:
* [Alex<EMAIL_ADDRESS>* [Mike<EMAIL_ADDRESS>* [Heather<EMAIL_ADDRESS>* [Sam<EMAIL_ADDRESS># __Application__
Click to view deployed application

branch_name: refs/heads/main


text:
# Bitrise.io

[![Build Status](https://app.bitrise.io/app/002b43ae8a42b6b1/status.svg?token=xT4EDBQWGNcSWJveU6IEVA&branch=master)](https://app.bitrise.io/app/002b43ae8a42b6b1)

[Bitrise](https://bitrise.io) is one of the modern and very promising CI services. Read [how Bitrise works](http://devcenter.bitrise.io/v1.0/docs/how-bitrise-works) article first to have better understanding.

Bitrise integrates with wide [list of services](https://www.bitrise.io/integrations). It operates with [workflows](http://devcenter.bitrise.io/docs/manage-your-bitrise-workflow) (analog of Jenkins job).

##### How to configure workflow for Android project on Bitrise.io:

1. Create new application at [Add new app](https://www.bitrise.io/apps/add)

2. Find your repository in repositories list

3. Follow the instructions (basic configuration with clone/build takes ~1 minute).
Bitrise automatically registers webhook, which makes our lives even simplier.

4. Configure build steps

    [.bitrise.yml](https://github.com/vgaidarji/ci-matters/tree/master/.bitrise.yml) contains full configuration without UI tests.

    [.bitrise-with-ui-tests.yml](https://github.com/vgaidarji/ci-matters/tree/master/.bitrise-with-ui-tests.yml) contains full configuration + UI tests.
    It uses ["Virtual Device Testing for Android step"](https://blog.bitrise.io/introducing-solid-and-snappy-virtual-device-testing-for-android).

    These configurations can be imported to bitrise.io. To achieve that create new workflow or edit existing, navigate to `Workflow Editor -> bitrise.yml` and paste file content there.

5. Add environment variables

6. If everything goes fine we get successful build

repository: aeciojr/ci-matters

repo_name: aeciojr/ci-matters


text:
Platea
======

Sample app for [Droidcon India 2014](https://droidcon.in/2014), and maybe the start of something new.

I'm interested in working on using a combination of mobile and wearable tech,
plus elements of machine learning and NLP, to make the whole concept of understanding
and using foreign languages a lot more interesting, intuitive, and a load of other adjectives
that probably don't make sense.

Anyway, as of now, this app's just a small demo on using Mobile Chrome Apps for Android dev.
The idea is to showcase useful phrases for 2-3 languages - probably French, German
and Greek - as well as audio samples for those phrases, to help someone who's just
landed in, say, Paris, Berlin or Athens, to get by.

You can also check out the proposal for my talk, featuring this app, [here](https://funnel.hasgeek.com/droidcon2014/1343-mobile-chrome-apps-html5-mobile-apps-done-right).

Build Instructions
===================

You're going to need the Android SDK, as well as the CCA tool. You can check out
installation instructions for those [here](https://github.com/MobileChromeApps/mobile-chrome-apps/blob/master/docs/Installation.md).
Just make sure you have the Android SDK Platform and Build Tools for Android 19, since MCA doesn't run on
anything higher than that. But fret not, the code will run just fine on newer Android builds.

Okay, so once you're set up with this, simple fork/clone this repo, and inside the repo,
run ```cca emulate android```, to test the app on an emulator. You will need an emulation device set up
using the AVD Manager; again, for further info, check [this](https://github.com/MobileChromeApps/mobile-chrome-apps/blob/master/docs/Develop.md) out.

After this, if you're feeling like [Richard the Lionheart](http://en.wikipedia.org/wiki/Richard_I_of_England),
feel free to run ```cca build android --debug```, which should give you an APK that you can load onto
your unsuspecting guinea pig of a smartphone.

Questions? Issues? Rants? Feel free to post an issue, or hit me up [here](http://rudimk.github.io/contact/).

repository: rudimk/platea

repo_name: rudimk/platea


text:
Oodi music library management tools
===================================

Oodi is a python library used to managing collections of audio files, transcoding files
between formats and tagging metadata to the files.

This module is a clean rewrite to replace 'soundforest' module I wrote earlier.

Naming Oodi
===========

Helsinki just got a very nice new central library called Oodi. I guess it's quite obvious why.

Installing codecs
-----------------

MacOS with homebrew:

    brew install -y flac lame opus-tools wavpack vorbis-tools vorbisgain

repository: hile/oodi

repo_name: hile/oodi


text:
# Docker Installation Guide

Congrats on making it this far!
Give yourself a pat on the back.
You are ready to set up Yacs on your computer.

## Welcome!

Yacs uses Docker and Docker Compose to manage its many pieces (services).
You'll read more about this in [Architecture](contributors/architecture), but for now we just need to install Docker.
Below are the instructions for installing Docker on macOS, Linux, and Windows.

## System Setup

### System Requirements

For development purposes, Yacs can be run on Linux or macOS.
Windows is not supported, and there are no plans to support it in the future.
If you have a windows machine though, that's fine!
You can either run Linux in a Virtual Machine, or dual-boot Linux alongside Windows (recommended).

It should be noted that in reality, Docker only runs on Linux (sort of).
However, the lovely folks over at Docker have created nice installers for macOS and Windows that make running Docker in a virtual environment a breeze!
We do not, however, support Docker for Windows due to issues we have encountered in the past.

### Installing Docker

#### macOS

Installing Docker on macOS is easy!
Just visit the [installation page][install-page] on the Docker website and download the installer.
Once the install is complete, you will want to allot Docker a minimum of 4GB of RAM. To do so, [open the Docker preferences][docker-prefs] and navigate to the [Advanced][advanced-section] section.
The Docker for Mac installer includes Docker Compose, so you are all done!

#### Notes for macOS users:
- Docker for Mac runs Linux in a Virtual Machine under the hood, which needs 4GB of RAM on its own. Because of this, we macOS users should have 8GB of RAM total. You can try it with less but unexpected results may occur.

#### Linux

Installing Docker on Linux is pretty easy as well!
The full documentation for installing Docker on Linux can be found [here][docker-linux], or on your distribution's website.

We will provide the easy version, which works for recent versions of Ubuntu and other common distributions.
Just open a terminal, enter the following command, and then follow the prompt to install Docker.

    curl -fsSL get.docker.com | sudo sh

Once the install is complete, enter the following command to enable docker for your user.
 Now just install Docker Compose with the following command.

    sudo curl -L https://github.com/docker/compose/releases/download/1.21.2/docker-compose-$(uname -s)-$(uname -m) -o /usr/local/bin/docker-compose && sudo chmod +x /usr/local/bin/docker-compose

#### Windows

As mentioned before, developing on Windows is not supported.
You will have to install Linux to work on Yacs.
If you are new to Linux, we recommend using Ubuntu.
You can either [install Ubuntu on a Virtual Machine][install-ubuntu-vm] or [install Ubuntu alongside Windows][install-ubuntu-win].

Once you have installed Linux, follow the [Linux Docker install steps](#linux)

##### Notes for Windows Users:
- If you are not comfortable installing an operating system, we recommend using a Virtual Machine over Dual Booting
- If you wish to use a Virtual Machine, you must have at least 8GB of RAM and either Windows 8.1 Professional Edition (**Not Home Edition**) or, preferably Windows 10
- Performance while using a Virtual Machine under Windows may suffer

## Congratulations!

You have finished installing Docker.

repository: YACS-RCOS/docs

gha_language: CSS

repo_name: YACS-RCOS/docs


text:
# DROP Measure Realization Package

DROP Measure Realization implements the Stochastic Jump Diffusion Vertex Edge.

## Class Components

 * [***JumpDiffusionEdge***](https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/measure/realization/JumpDiffusionEdge.java)
 JumpDiffusionEdge implements the Deterministic and the Stochastic Components of a Rd
 Marginal Random Increment Edge as well the Original Marginal Random Variate.

 * [***JumpDiffusionEdgeUnit***](https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/measure/realization/JumpDiffusionEdgeUnit.java)
 JumpDiffusionEdgeUnit holds the Jump Diffusion Rd Unit Edge Realizations.

 * [***JumpDiffusionVertex***](https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/measure/realization/JumpDiffusionVertex.java)
 JumpDiffusionVertex holds the Snapshot Values of the Realized Rd Variable - its Value,
 whether it has terminated, and the Cumulative Hazard Integral - and Time.

 * [***StochasticEdgeDiffusion***](https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/measure/realization/StochasticEdgeDiffusion.java)
 StochasticEdgeDiffusion holds the Edge of the Diffusion Stochastic Evaluator Outcome.

 * [***StochasticEdgeJump***](https://github.com/lakshmiDRIP/DROP/tree/master/src/main/java/org/drip/measure/realization/StochasticEdgeJump.java)
 StochasticEdgeJump holds the Edge of the Jump Stochastic Evaluator Outcome.

## References

 * Almgren, R. F., and N. Chriss (2000): Optimal Execution of Portfolio Transactions Journal of Risk
 3 (2) 5-39

 * Almgren, R. F. (2009): Optimal Trading in a Dynamic Market
 https://www.math.nyu.edu/financial_mathematics/content/02_financial/2009-2.pdf

 * Almgren, R. F. (2012): Optimal Trading with Stochastic Liquidity and Volatility SIAM Journal of
 Financial Mathematics 3 (1) 163-181

 * Geman, H., D. B. Madan, and M. Yor (2001): Time Changes for Levy Processes Mathematical Finance
 11 (1) 79-96

 * Jones, C. M., G. Kaul, and M. L. Lipson (1994): Transactions, Volume, and Volatility Review of
 Financial Studies 7 (4) 631-651

## DROP Specifications

 * Main                     => https://lakshmidrip.github.io/DROP/
 * Wiki                     => https://github.com/lakshmiDRIP/DROP/wiki
 * GitHub                   => https://github.com/lakshmiDRIP/DROP
 * Repo Layout Taxonomy     => https://github.com/lakshmiDRIP/DROP/blob/master/Taxonomy.md
 * Javadoc                  => https://lakshmidrip.github.io/DROP/Javadoc/index.html
 * Technical Specifications => https://github.com/lakshmiDRIP/DROP/tree/master/Docs/Internal
 * Release Versions         => https://lakshmidrip.github.io/DROP/version.html
 * Community Credits        => https://lakshmidrip.github.io/DROP/credits.html
 * Issues Catalog           => https://github.com/lakshmiDRIP/DROP/issues

repository: fairhopeweb/DROP

repo_name: fairhopeweb/DROP


text:
# Laravel SRI

Subresource Integrity (SRI) package for Laravel

[![Latest Version on Packagist](https://img.shields.io/packagist/v/sebdesign/laravel-sri.svg)](https://packagist.org/packages/sebdesign/laravel-sri)
[![Software License](https://img.shields.io/badge/license-MIT-brightgreen.svg)](LICENSE.md)
[![Build Status](https://img.shields.io/travis/sebdesign/laravel-sri/master.svg)](https://travis-ci.org/sebdesign/laravel-sri)
[![StyleCI](https://github.styleci.io/repos/71842300/shield)](https://github.styleci.io/repos/71842300)

Reference and generate [Subresource Integrity (SRI)](https://www.w3.org/TR/SRI/) hashes from your Laravel Elixir asset pipeline.

## Installation

You can install the package via composer:

```bash
composer require sebdesign/laravel-sri
```

Laravel 5.5 uses Package Auto-Discovery, so doesn't require you to manually add the service provider.
If you don't use auto-discovery or you are using an older version, you must add the following:

```php
// config/app.php
'providers' => [
    Sebdesign\SRI\SubresourceIntegrityServiceProvider::class,
];
```

## Usage

This package is aimed to reference SRI hashes for `css` and `js` files from a `sri.json` file in your `/public` folder. In order to generate this file, see the [laravel-elixir-sri](https://github.com/sebdesign/laravel-elixir-sri) repository.

To reference the generated hashes from the `sri.json` in your views, you may use the `integrity` helper function with the name of the file you are using in your `elixir` or `asset` function.

As a fallback, if the given file is not found in the `sri.json`, **it will generate the appropriate hashes on the fly** for your convenience.

```php
// Use with elixir() function
<link
    rel="stylesheet"
    href="{{ elixir('css/app.css') }}"
    integrity="{{ integrity('css/app.css') }}"
    crossorigin="anonymous">

// Use with asset() function
<script
    src="{{ asset('js/app.js') }}"
    integrity="{{ integrity('js/app.js') }}"
    crossorigin="anonymous">
</script>
```

If you have set the output folder for the `sri.json` in a different location in your Gulpfile, you can specify its `path` on the `config/sri.php`.

```php
// config/sri.php
'path' => '/public/assets',
```

You can also override the config options by passing an array as a second argument on the `integrity` helper function:

```php
// Use different hash algorithm
<link
    rel="stylesheet"
    href="{{ elixir('css/app.css') }}"
    integrity="{{ integrity('css/app.css', ['algorithms' => ['sha384']]) }}"
    crossorigin="anonymous">
```

## Testing

``` bash
composer test
```

### Changelog

Please see [CHANGELOG](CHANGELOG.md) for more information on what has changed recently.

## Contributing

Please see [CONTRIBUTING](./github/CONTRIBUTING.md) for details.

## Security
If you discover any security related issues, please email<EMAIL_ADDRESS>instead of using the issue tracker.

## License

The MIT License (MIT). Please see [License File](LICENSE.md) for more information.

repository: sebdesign/laravel-sri

gha_language: PHP

repo_name: sebdesign/laravel-sri


text:
pycaesar
========
Caesar's cipher in python. GUI bonus!
GUI is made in tkinter.
![ScreenShot](pycaesar-example.jpg)

Hint:
$ python caesar-gui.py

It's possible you will find some minor bugs.

repository: kozmonaut/pycaesar

repo_name: kozmonaut/pycaesar


text:
# baby-name-scraper
Scrapes U.S. baby names from the Social Security Administration.
Uses Node.js.

## Running
```
npm install
npm start
```

Good stuff is in `./csv`.

_**Note:**_ You'll need a relatively recent version of Node, one that supports [`Object.assign`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign). If you have [`nvm`](https://github.com/creationix/nvm) installed, you can just `nvm use` and you'll be good to go.

## Why?
I had a baby! Yay. I have paternity leave! Also yay.

I wanted to play with baby name data, and found Hadley Wickham's [data-baby-names](https://github.com/hadley/data-baby-names) scraper/parser. But, it didn't work! I eventually figured out that it's because SSA went SSL (good on them), so all that was needed to get the R scraper to work was `http` -> `https`.

But by then, I'd already decided it would be nice to have a version of this that was easier to run than "install R, install R libs, make sure Ruby install is up to date, wade into this and that". Something more like `npm start`. And here we are.

license: ISC

repository: ericsoco/baby-name-scraper

repo_name: ericsoco/baby-name-scraper


text:
# Hasadna Kubernetes Environment

Infrastructure as code for The Public Knowledge Workshop

See [docs/argocd.md](docs/argocd.md) for defining deployed apps and continuous deployment.

## Deleted code

See this commit for some old deleted code which might be useful in the future https://github.com/hasadna/hasadna-k8s/tree/6cf0d6b0d88170dadc85f16790caa9087b051a14


text:
---
layout:     post
title:      "Help Scout Command Line Client"
subtitle:   "Reading conversations from the command line"
date:       2015-04-18
tags:       [php]
author:     "Craig Davis"
header-img: "img/headers/gravel.jpg"
---

I've started on a new toy project - a [command line client for Help Scout](https://github.com/helpscout/helpscout-cli-php). This project serves two purposes:

* Provide a tool for me to use during the work day
* Be an example of using the excellent [Help Scout API](http://developer.helpscout.com/help-desk-api/).

## Current Commands

    Help Scout Command Line Client version 0.0.1 by Help Scout

    Usage:
      command [options] [arguments]

    Options:
      -h, --help            Display this help message
      -q, --quiet           Do not output any message
      -V, --version         Display this application version
          --ansi            Force ANSI output
          --no-ansi         Disable ANSI output
      -n, --no-interaction  Do not ask any interactive question
      -v|vv|vvv, --verbose  Increase the verbosity of messages: 1 for normal output, 2 for more verbose output and 3 for debug

    Available commands:
      customer   Show customer details
      help       Displays help for a command
      list       Lists commands
      mailbox    Show mailbox details
      mailboxes  List all mailboxes
      setup      Configure this Help Scout client
      version    Show version information
      zen        Display a Zen koan, used as an API heartbeat

## Example Output

    $ helpscout mailboxes

    ————————————————————————————————————————————————————————————————————————————————
                                  Help Scout Mailboxes
    ————————————————————————————————————————————————————————————————————————————————
     ID         Name                           Email
    ————————————————————————————————————————————————————————————————————————————————
     [25590]    Research<EMAIL_ADDRESS>     [85]       Help Scout<EMAIL_ADDRESS>     [2641]     Developer Support<EMAIL_ADDRESS>     [20512]    Customer Success<EMAIL_ADDRESS>

extension: markdown