text:
# Machine_Learning [![Build Status](https://travis-ci.org/eduardo-salazar/machine_learning.svg?branch=master)](https://travis-ci.org/eduardo-salazar/machine_learning)
Basic machine learning technique in Ruby. This is for pure understanding of the techniques

# Techniques
1. Decision Trees [On Progress]
  How DT is build:
  * Check the model for the base case
  * Iterate through all the attributes
  * Get the normalized information gain from splitting the attributes
  * Let best_attr be the attribute with the highest information gain
  * Create a decision node that splits on the best_attr
  * Work on the sublists that are obtained by splitting on best_attr and add those
  nodes a child nodes.

  Training Data Attributes [data/customer_purcharse_training.csv]
  ## Placement:
    What type of stand the CD is displayed on: an end rack,special offer bucket
    , or a standard rack
  ## Prominence:
    What percentage of the CDs on display are from that author CDs.
  ## Pricing:
    What percentage of the full price was the CD at the time of purchase,
    unless it is an old, back catalog title.
  ## Eye Level:
    Was the product displayed at eye level position? The majority of sales
    will happen when a product is displayed at the eye level.
  ## Customer purchase:
    What was the outcome? Did the customer purchase?

2. Bayesian Networks [On Progress]
3. Artificial Neural Networks [On Progress]
4. Association Rules learning [On Progress]
5. Support Vector Machines [On Progress]
6. Clustering [On Progress]

gha_language: Ruby


text:
# ZmProxy

This software is used to intercept and apply modifications to the traffic between a Zimbra Proxy and Zimbra Mailboxes. If you don't know what a Zimbra Proxy is, You can read about it here: [https://wiki.zimbra.com/wiki/Zimbra_Proxy_Guide](https://wiki.zimbra.com/wiki/Zimbra_Proxy_Guide)

This work for all kind of client access:

* POP3
* IMAP
* Webmail
* ActiveSync
* Zimbra Outlook Connector

## What this try to solve?

### Zimbra Migrations
Suppose you need to move a lot of users and data from one Zimbra Platform to another, like we do at [ZBox](http://www.zboxapp.com), and given the size of the migration, you can't move all the mailboxes at once, so you have to do it in groups.

This procedure have the following inconvenients:

* You have to update the configuration of the clients for all the migrated users,
* Your users will need to learn a new Webmail URL,
* It's not transparent for the end user,
* It's a lot of work for you

### Network and OpenSource Deployments
Not a hot topic for Zimbra Inc., sorry guys, but lets be honest about it, some companies can't afford Zimbra Network for all the employees, so they use two setup platform.

The main problem with this is that you have to configure your clients with to kind of information.

## Tutorial
This tutorial is based on the following setup:

* One Zimbra Mailbox v6, that we want to migrate to,
* Multi Server Zimbra, with 1 Zimbra Proxy, and 2 Zimbra Mailboxes

Also, the new Zimbra Proxy should be running on CentOS 7.

### 1. Install Docker on the Zimbra Proxy Server

```
$ yum install epel-release -y
$ yum install docker -y
$ systemctl enable docker
$ systemctl start docker
```

### 2. Configure Zimbra Nginx Templates
This config is going to use a running Docker listen on the `9090` port.

 ```
 # Backup directory
 $ cp -a /opt/zimbra/conf/nginx/templates /opt/zimbra/conf/nginx/templates.backup
 $ curl -k https://raw.githubusercontent.com/ITLinuxCL/zimbra_intercepting_proxy/master/examples/nginx.conf.mail.template > /opt/zimbra/conf/nginx/templates/nginx.conf.mail.template
 $ curl -k https://raw.githubusercontent.com/ITLinuxCL/zimbra_intercepting_proxy/master/examples/nginx.conf.web.template > /opt/zimbra/conf/nginx/templates/nginx.conf.web.template
 $ curl -k https://raw.githubusercontent.com/ITLinuxCL/zimbra_intercepting_proxy/master/examples/nginx.conf.zmlookup.template > /opt/zimbra/conf/nginx/templates/nginx.conf.zmlookup.template
 $ chown zimbra.zimbra -R /opt/zimbra/conf/nginx/templates/
 ```

### 3. Create and Admin User
We need an admin user to lookup the mailbox for the account, this admin needs to have a **non-expiring token**.

```
$ zmprov ca<EMAIL_ADDRESS>Password \
  zimbraIsAdminAccount TRUE \
  zimbraAdminAuthTokenLifetime 100d \
  zimbraAuthTokenLifetime 100d
```

### 4. Start the Container

```
# Interactive Mode
$ docker run --rm -ti --dns=<IP_ADDRESS> -p 9090:9090 \
  -e<EMAIL_ADDRESS>\
  -e ZIMBRA_PASSWORD=Password \
  -e NAMESERVERS=<IP_ADDRESS> \
  -e ZIMBRA_SOAP=https://any_new_mailbox:7071/service/admin/soap \
  -e DEFAULT_MAILBOX_IP=<IP_ADDRESS> \
  -e DEFAULT_DOMAIN=example.com \
  -e MAILBOXES_MAPPING='<IP_ADDRESS>:8080:7110:7143:true;<IP_ADDRESS>:80:110:143' \
  -e PREFIX_PATH=/zimbra \
  -e VERBOSE=true \
  itlinuxcl/zimbra_zip

# Background just change this line
$ docker run -d --name zimbra_zip --dns=<IP_ADDRESS> -p 9090:9090 \
  ......
```

You can check de running docker in background with:

```
docker logs zimbra_zip -f
```

About the variables:

* `ZIMBRA_USER`, is the admin user,
* `ZIMBRA_PASSWORD`, password for the admin user,
* `NAMESERVERS`, an IP address of a DNS server that can resolv all mailboxes, including old and new,
* `ZIMBRA_SOAP`, url of a mailbox where to do the lookups,
* `DEFAULT_MAILBOX_IP`, one of the mailboxes on the new platform
* `DEFAULT_DOMAIN`, default domain to add when only the user part is sent
* `PREFIX_PATH`, the Zimbra 6 use a prefix when sending requests,
* `MAILBOXES_MAPPING`, this holds the information of the port used in every mailbox.

The syntax of `MAILBOXES_MAPPING` is:

```
IP,WEB_P,POP_P,IMAP_P:REMOVE_PREFIX;IP,WEB_P,POP_P,IMAP_P:REMOVE_PREFIX;
```

Where:

* `IP`, ip of a mailbox
* `WEB_P,POP_P,IMAP_P`, ports where listen the webmail, pop3, and imap services
* `REMOVE_PREFIX`, it ZmProxy shoud remove the `/zimbra` prefix for this mailbox

You **must** list all the mailboxes here.

### 5. Re-configure Zimbra Proxy and restart

```
$ /opt/zimbra/libexec/zmproxyconfgen
$ /opt/zimbra/bin/zmproxyctl restart
```

### 6. Check status
If you run the container in Interactive mode, you should see the logs on your screen, if not
you can run the following command:

```
$ docker logs zimbra_zip -f
```

## Thanks

* To the Zimbra folks for a great product, and
* [@igrigorik](http://twitter.com/igrigorik) for [em-proxy](https://github.com/igrigorik/em-proxy)

## Contributing

1. Fork it ( https://github.com/pbruna/zimbra_intercepting_proxy/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 a new Pull Request

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
### Please follow the general troubleshooting steps first:

- [ ] Ran this?
- [ ] Ran that?
- [ ] Seeing permission errors?

### Description
<!-- How has this issue affected you? What are you trying to accomplish? -->
<!-- Providing context helps us come up with a solution that is most useful in the real world -->

<!-- Provide a general summary of the issue in the Title above -->

### Environment

- Version: 2.0.0-beta.X
- Browser: [all | Chrome XX | Firefox XX | IE XX | Safari XX | Mobile Chrome XX | Android X.X Web Browser | iOS XX Safari | iOS XX UIWebView | iOS XX WKWebView ]
- Language: [all | TypeScript X.X | ES6/7 | ES5 | Dart]
- Operating System: [Windows | Mac | Linux | BSD]

### Steps to Reproduce
<!-- Provide a link to a live example, or an unambiguous set of steps to -->
<!-- reproduce this bug. Include code to reproduce, if relevant -->
1.
2.
3.

### Expected Behavior
<!-- Tell us what should happen -->

### Current Behavior
<!-- Tell us what happens instead of the expected behavior -->

### Possible Solution
<!-- Not obligatory, but suggest a fix/reason for the bug, -->

### Additional details / screenshot

![Screenshot]()

<!-- ### Components -->
<!-- ### Issue Type -->
<!-- ### Linked Issues -->

repository: nevesnunes/env

gha_language: Python

gha_license_id: MIT

repo_name: nevesnunes/env


text:
# Race Car Example using my managed ECS  (mmECS)
This is a simple and interactive Unity3d (2017 version) example project to show how to use mmECS (Entity Component System).
This (ECS) Framework specifically made for C# and Unity, using unity event manager to register and listen when certain code needs to be executed.

This example aims to demonstrate :

1. Create Components, attach them to Entities (GameObjects)

2. Create Events (to get the systems to communicate)

3. Create Systems (to do all the logic of the game)

## Install for Editor
To Install download mmECS files to a folder.
Go to \mmECS_RaceCar_Example\mmGameLib_UnityEditor
there are 2 files

•51-EntityComponent-NewEntityComponent.cs

•52-EntitySystem-NewEntitySystem.cs

copy them to C:\Program Files\Unity\Editor\Data\Resources\ScriptTemplates and add the two template files
These 2 show up in your editor everytime you want to add a "new" script

Next Restart or Open your Unity project and go to Edit/ProjectSettings/Script Execution Order and Set EntityManager to -200 and Entity to -100.

Create the usual script folders in Assets folder

	Components

	Systems

	Resources

	Scenes

	Sprites

	….

Drag in mmGameLib folder and add it to Assets

Create a game object – call it GameSystem (this is where everything happens)

	Add following components:

	Add mmGameLib -> EventManger

	Add ALL game systems as components.  Each system should implement following:

    void OnEnable()

    {
        EventManager.StartListening("GameEvent", Handle);
    }

    void OnDisable()
    {
        EventManager.StopListening("GameEvent", Handle);
    }

    void Handle(string value)
    {
    }

All other game objects

	Add any number of components that has the following method:

	private void OnEnable()
    {
        ObjectTracker.Register(this.GetType(), this.gameObject);
    }

## Sample Screen

![game image](RaceCarGame.png)

ECS explained here https://www.gamedev.net/articles/programming/general-and-gameplay-programming/understanding-component-entity-systems-r3013/


text:
Yii 2 REST Project Template
============================

This project was branched via the Yii2 Basic Project Template
and has been configured to be used just as a REST API. It also contains
a docker-compose configuration to get up and running using docker quickly.
It requires docker-compose >= 1.6 installed.

The template contains the basic features to build a simple api.
It includes all commonly used configurations that would allow you to focus on adding new
features to your application.

DIRECTORY STRUCTURE
-------------------

      assets/             contains assets definition
      commands/           contains console commands (controllers)
      config/             contains application configurations
      controllers/        contains Web controller classes
      mail/               contains view files for e-mails
      models/             contains model classes
      modules/            contains api modules
      runtime/            contains files generated during runtime
      tests/              contains various tests for the basic application
      vendor/             contains dependent 3rd-party packages
      views/              contains view files for the Web application
      web/                contains the entry script and Web resources

REQUIREMENTS
------------

The minimum requirement by this project template that your Web server supports PHP 5.4.0.
It also requires rewrites enable whether via nginx or apache2.

INSTALLATION
------------

### Install via Docker

TODO

CONFIGURATION
-------------

### Database

Edit the file `config/db.php` with real data, for example:

```php
return [
    'class' => 'yii\db\Connection',
    'dsn' => 'mysql:host=localhost;dbname=yii2basic',
    'username' => 'root',
    'password' => '1234',
    'charset' => 'utf8',
];
```

**NOTES:**
- Yii won't create the database for you, this has to be done manually before you can access it.
- Check and edit the other files in the `config/` directory to customize your application as required.

TESTING
-------

TODO
Most likely not working at the moment.


text:
---
category: General
path: '/login'
title: 'Authentication'

layout: default
---

Each request **must** include the current user's authentication details, encoded as
[HTTP Basic Authentication](http://en.wikipedia.org/wiki/Basic_access_authentication); that is, each
request must include an **`Authorization: Basic xxxx`** header, where **`xxxx`** is the [Base64](http://en.wikipedia.org/wiki/Base64)
encoding of a string constructed as **`identifier:secret`**, where **`identifier`** is either the user's username
or email, and **`secret`** is either the user's password or their API key.

> We **strongly** suggest that you use a user's API key to authenticate them, since it decreases the
> attack surface that a hacker can use to steal their password, which the user may be using on more than
> one site.

A user's API key can be found on the edit page for their employee profile (**`https://[subdomain].mytribehr.com/users/edit/{user_id}/account`**).
Alternatively, you can make an API request (authenticating using the user's password, naturally) to
**`/users/me.json?requireApiKey=true`** (as documented in the Users section, below). The response to this
request will include the user's API key, generating one automatically if they don't already have one.

gha_language: JavaScript


text:
a front-end framework

![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)![Jig](https://github.com/carlosmaniero/jigjs/workflows/Jig/badge.svg)
![npm version](https://badge.fury.io/js/jigjs.svg)
[![Coverage Status](https://codecov.io/gh/carlosmaniero/jigjs/branch/main/graph/badge.svg?flag=jigjs)](https://codecov.io/gh/carlosmaniero/jigjs)
![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)

jigjs is a web library that combines reactiveness with OOP. Making it easy to react to
object side-effects.

```typescript
import {observable, observing, observe} from "jigjs/reactive";

@observable()
class Greater {
    @observing()
    private name;

    constructor(name: string) {
        this.name = name;
    }

    say() {
        return `Hello, ${this.name}!`
    }

    updateName(name: string) {
        this.name = name;
    }
}

const greater = new Greater("World!");

const subscription = observe(greater, () => {
    console.log(greater.say());
});

greater.updateName('Universe'); // calls the observer and prints "Hello, Universe"
greater.updateName('Mars'); // calls the observer and prints "Hello, Mars"

subscription.unsubscribe();

greater.updateName('Earth'); // does not prints anything
```

## Installation

```bash
npm install -g jigjs
```

## Components

A component is a small UI peace that manages its own state. Whenever the class fields
decorated with `@observing` changes the component is re-rendered.

```typescript
import {component, html} from "jigjs/components";
import {observing} from "jigjs/reactive";

@component()
export class CounterComponent {
    @observing()
    private number: number;

    constructor(initialCount = 0) {
        this.number = initialCount;
    }

    reset() {
       this.number = 0;
    }

    render() {
        return html`
            <button onclick="${() => { this.number++ }}">+</button>
            ${this.number}
            <button onclick="${() => { this.number-- }}">-</button>
        `;
    }
}
```

Using the component:

```typescript
import {component, html, renderComponent} from "jigjs/components";

@component()
export class CounterPage {
    private readonly counter: CounterComponent;

    constructor() {
        this.counter = new CounterComponent();
    }

    render() {
        return html`
            <h1>Counter</h1>

            ${this.counter}

            <hr>

            <button onclick=${this.counter.reset()}>Reset counter</button>
        `;
    }
}

renderComponent(document.querySelector('#root'), new CounterPage());
```

In jigjs you control the component instance. There isn't a magic way to update a component props. The component props
is its state, and you update it by using class methods.

## Styling the component

There is a css-in-js module for jigjs.

Read more about jigcss [here](/jigcss).

## Creating an APP

As showed in the previous example, you can use jigjs as a simple library by using the `renderComponent` function.
However, it is also possible to use jigjs as a framework.

To start a jigjs project you can use the cli:

```bash
npm install -g jigjs
npx jigjs-new-project
```

![Installation demo](jig/ghassets/gif-fast.gif)

It comes with a `Router` system that enables `Single Page Applications`, Native `Server Side Rendering` and built-in
`build system`.

### Routing

A router is composed by a `path`, a `name` and `handler`.

- `path` is used to match the user request.
- `name` is used to reverse a route.
- `handler` is called when the path matches the user request.

```typescript
new Routes([
    {
        path: '/',
        name: 'index',
        handler(params, render) {
            render(new IndexPage());
        }
    },
    {
        path: '/hello/:name',
        name: 'hello',
        handler(params, render) {
            render(new HelloPage(params.name));
        }
    },
    {
        path: '/hello/?name=:name',
        name: 'hello:with-query',
        handler(params, render) {
            render(new HelloPage(params.name));
        }
    },
    {
        path: '/hello/#:name',
        name: 'hello:with-hash',
        handler(params, render) {
            render(new HelloPage(params.name));
        }
    }
]);
```

For more examples of router matchers: https://github.com/rcs/route-parser

### Navigation

To redirect users to a specific URL you can use the `Navigation` object.

```typescript
 const routerModule = new RouterModule(window, platform, new Routes([
    {
        path: '/',
        name: 'index',
        handler() {
            // ...
        }
    },
    {
        path: '/hello/:name',
        name: 'hello',
        handler() {
            // ...
        }
    }
]));

routerModule.navigation.navigateTo('hello', {name: 'world'});
routerModule.navigation.navigateTo('index');
```

### Async Handlers

When you need to process async functions in your components you can make your handler to return a promise.

```typescript
const routerModule = new RouterModule(window, platform, new Routes([
    {
        path: '/user/:id',
        name: 'show-user',
        async handler(params, render) {
            render(new PageLoadingComponent());
            const user = await fetchUser(params.id);
            render(new UserPage(user));
        }
    }
]));
```

The server will only release the request when the promise is resolved. You can call the `render` function as much as
you want, this is useful to render loading components that will be visible when the code is executed from the
client-side.

### Custom Response

The handler receives the response object that can be used to add custom headers and status code.

There is no need to specify the response body since it will be always the render result.

```typescript
const routerModule = new RouterModule(window, platform, new Routes([
    {
        path: '/user/:id',
        name: 'show-user',
        async handler(params, render, transferState, response) {
            try {
                const user = await fetchUser(params.id);
                render(new UserPage(user));
            } catch(e) {
                response.statusCode = 404;
                response.headers['custom-error'] = 'User not found';

                render(new UserNotFoundPage());
            }
        }
    }
]));
```

### Transfer State

When you make a request to the jigjs server, it will pre-render the entire page and return it as raw HTML. Coming to
browser, jigjs will execute the same code that had executed on server. It means that, any request you performed at the
server-side will be performed again.

To prevent this kind of behavior you must use `TransferState`. The`TransferState` is a key-value object that can
be shared from server to browser. Once the server stores a value using `TransferState.setState` it will be available
to browser thought the `TransferState.getState`.

```typescript
const routerModule = new RouterModule(window, platform, new Routes([
    {
        path: '/my-transfer-state-page',
        name: 'my-transfer-state-page',
        async handler(params, render, transferState) {
            if (transferState.hasState('page-title')) {
                render(new MyPage(transferState.getState('page-title')));
                return;
            }

            render(new PageLoadingComponent());
            const pageTitle = await asyncMethodThatReturnsANicePageTitle();
            transferState.setState('page-title', pageTitle);
            render(new MyPage(pageTitle));
        }
    }
]));
```

### SSR limitations

There is no global variable like `window` or `document` because global variables into a back-end application leads to concurrency
issues. If you want to access the `window` or `document` you can use the window injected into the `AppFactory`.

For third-party libraries you can use the `Platform` object to verify if the code is being executed from browser.

repository: bryan-matheus/jigjs

branch_name: refs/heads/main

repo_name: bryan-matheus/jigjs


text:
# Undergraduate Graduation Project

Undergraduate Graduation Project—— Online web book app

# 本科毕业设计作品

本科毕业设计项目——在线 web 书城 app

## 效果演示

### 首页

![cduyzh web book](https://github.com/cduyzh/UndergraduateGraduationProject/blob/master/gif/web_book1.gif)

### 登录注册

![cduyzh web book](https://github.com/cduyzh/UndergraduateGraduationProject/blob/master/gif/web_book2.gif)

### 图书信息查看

![cduyzh web book](https://github.com/cduyzh/UndergraduateGraduationProject/blob/master/gif/web_book3.gif)

### 阅读读书

![cduyzh web book](https://github.com/cduyzh/UndergraduateGraduationProject/blob/master/gif/web_book4.gif)

### 更多图书

![cduyzh web book](https://github.com/cduyzh/UndergraduateGraduationProject/blob/master/gif/web_book5.gif)

### 后台界面

![cduyzh web book](https://github.com/cduyzh/UndergraduateGraduationProject/blob/master/gif/web_book6.gif)

## special suggestion

This project because based on company's homemade scaffolding structures, it involves a lot of private information, with the company's technology accumulation, I can't put the scaffold without permission, the open source, so only a single file vue project page, just for your reference.If I am interested in the project, I am willing to refactor and optimize the graduate design. I can contact me in the blog.

[Click To Visit My Blog](http://www.cduyzh.com/)

## 特别提示

本项目由于基于公司的自制的脚手架进行搭建，里面涉及到许多私密信息，与公司技术积累，本人未经同意是不能把脚手架开源出来，所以只有单文件 vue 的项目页面，仅供大家参考。若实在对项目有兴趣，愿意作为毕业设计进行重构和优化的大学生，可以在博客联系到我。

[点击访问我的博客](http://www.cduyzh.com/)

## Background code

This project USES node.js combined with express framework and MongoDb database to develop the background system.Background and database connection, after all, the interface use cases basically manipulate the database, there is an increase, delete, change, check the function, belong to the relatively primary use, only for graduation design use.

> Finally, I graduated from 2018 years, main front-end developer, minor in the back-end, are trying to do the whole development of stack, technology co., LTD., the improvement of the undergraduate course work is friendly, the whole project takes a week to complete, the back-end database from self-study to link, write interface spent four days of time, the background a bit weak, the background of the code will also be put into the warehouse for your reference.

## 后台代码

本项目使用 node.js 结合 express 框架以及 MongoDb 数据库一起开发出的后台系统。后台与数据库进行联系，毕竟接口用例都基本操纵了数据库，有增，删，改，查的功能，属于比较初级的用法，仅用于毕业设计使用。

> 最后，本人 18 年毕业，主攻前端开发，副修后端，正努力做全栈开发，技术有限，本科作品的完善度也友善，整个项目用时一周完成，其中后端从自学到能链接数据库，写接口花了 4 天的时间，后台稍显薄弱，后台的代码也将放入仓库供各位借鉴。

## Frequently asked questions

1.  This project belongs to the whole development of the stack, so the back-end database, hope everybody to study, if the backend is not very understanding, I also provides a mock data, in the index. The js, whether can be configured in the introduction, the default is introduced, if do not interact with the database, a lot of interface looks more rigid, I only provide personal configuration files and related code as a reference.
2.  The front-end project has two entrances, because the scaffold company rewrote the vue - cli supports multiple entry package, so everyone's development and compile scaffold does not support multiple entry, will require a separate entrance to the things in the folder, in which background management is relatively simple, because due to time relationship do more hasty, hope understanding.

## 常见问题

1.  本项目属于全栈开发，所以后端数据库的问题，希望大家自己去研究，如果对后端不是很理解，我也提供了 mock 数据，在 index.js 中可以配置是否引入，默认为引入，如果不跟数据库交互的话，很多接口看起来就比较死板了，我仅提供个人的配置文件和相关代码作为参考。
2.  前端项目有 2 个入口，因为公司的脚手架改写了 vue-cli 支持多入口打包，所以大家的脚手架不支持多入口开发和编译的话，需要单独将入口文件夹内的东西提出来，其中后台管理端较为简单，因为由于时间关系做的比较仓促，望谅解。

repository: cduyzh/online-web-book-shop

repo_name: cduyzh/online-web-book-shop


text:
# Image Format

The main Tesseract.js functions (ex. recognize, detect) take an `image` parameter.  The image formats and data types supported are listed below.

Support Image Formats: **bmp, jpg, png, pbm, webp**

For browser and Node, supported data types are:
 - string with base64 encoded image (fits `data:image\/([a-zA-Z]*);base64,([^"]*)` regexp)
 - buffer

For browser only, supported data types are:
 - `File` or `Blob` object
 - `img` or `canvas` element

For Node only, supported data types are:
 - string containing a path to local image

Note: images must be a supported image format **and** a supported data type.  For example, a buffer containing a png image is supported.  A buffer containing raw pixel data is not supported.


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).

## [6.7.0] - 2023-05-08
### Added
* New flag `-no-prefix` to exclude the prefix (e.g. "v") from the printed version.

### Changed
* Use the `-prefix`-flag to allow parsing non-standard version prefixes (e.g. "ver")

## [6.6.0] - 2023-05-08
### Changed
* Upgrade Golang to 1.20 and update dependencies.

## [6.5.0] - 2022-06-24
### Changed
* Use [distroless/static:nonroot](https://github.com/GoogleContainerTools/distroless/tree/main/base) as
  base image for the dockerized version of `git-semver` and build with Golang 1.18.

## [6.4.0] - 2022-06-24
### Changed
* If two annotated tags point to the same commit `git-semver` will now select the one that
  was created last. E.g.

        $ git tag -a -m "Release candidate" 1.1.0-rc.1
        $ git-semver
        1.1.0-rc.1
        $ git tag -a -m "Final release" 1.1.0
        $ git-semver
        1.1.0

  Previously the behavior was undefined. Thanks [@igor-petrik-invitae](https://github.com/igor-petrik-invitae)
  for the issue report!

## [6.3.0] - 2022-05-20
### Added
* `git-semver` can now be installed with Homebrew

        $ brew install mdomke/git-semver/git-semver

## [6.2.0] - 2022-03-10
### Added
* Also build binaries for Windows

## [6.1.1] - 2021-09-16
### Fixed
* The ability to point `git-semver` to a different repository location was broken in 6.1.0
  and has been fixed by [@masonkatz](https://github.com/masonkatz).

## [6.1.0] - 2021-08-25
### Added
* A new flag `-guard` has been introduced to avoid accidentally overwriting production
  versions with a pre-release version. Consider that we have a tag `1.2.3-rc.1` and invoke
  `git-semver` with `-no-patch` we would get the version `1.2`, which would overwrite a previous
  version that was generated from the tag `1.2.2`. The `-guard` flag will enforce that the
  pre-release identifier is always included in the output regardless of the usage of shorthand
  options like `-no-patch`, `-no-pre`, etc.

## [6.0.3] - 2021-08-23
### Fixed
* The pre-release tag was parsed incorrectly if it included another dash. E.g.: `1.2.3-pre-release.1`
  This has been fixed by [@ckoehn](https://github.com/ckoehn).

## [6.0.2] - 2021-07-13
### Changed
* Upgrade Golang to 1.16 and `go-git` to 5.4.2
* Upgrade golangci-lint to `v1.41` and fix some linting errors.
* Switch to `golang:1.16-buster` as builder-image

## [6.0.1] - 2020-12-08
### Fixed
* The default log sort-order was finding the wrong tag. Switching to commiter time
  based sorting improves the situation, but eventually the concrete algorithm from
  git describe has to be reimplemented.

## [6.0.0] - 2020-10-28
### Changed
* Remove external dependency to git with a pure Go based implemenation.

## [5.0.0] - 2020-10-08
### Changed
* The SemVer compliance for "development versions" originating from a pre-release
  tag has been improved. Previously the pre-release version has been incremented
  before attaching the `dev.X` suffix. As pointed out by @choffmeister this results
  in a not compliant version sorting since

      1.2.3-rc.2.dev.1 > 1.2.3-rc.2

  because a larger set of pre-release fields has a higher precedence than a smaller
  set, if all of the preceding identifiers are equal [1]. A development version
  originating from the tag `1.2.3-rc.1` will now result in `1.2.3-rc.1.dev.1`.
* The dev-suffix added to a version that is derived from a tagged version is now
  formatted as `dev.X`. This will enforce proper sorting since dot-separted identifiers
  are compared individually and identifiers consisting only of digits will be compared
  numerically. So that

      dev1 < dev10 < dev2

  yields the wrong order whereas

      dev.1 < dev.2 < dev.10

  works as expected. Thanks [@choffmeister](https://github.com/choffmeister).

* The size of the docker image has been reduced to 25MB by [@choffmeister](https://github.com/choffmeister).
* The commonly used prefix "v" will be automatically detected by the parser now and the
  `-prefix` option is now only used to add a prefix that was not part of the tag before.
* Moved from Travis to GitHub Actions.

## [4.0.1] - 2020-06-05
### Added
* Publish binaries upon release [@schorzz](https://github.com/schorzz).

## [4.0.0] - 2020-04-10
### Changed
* Use semantic import path versioning.
* Allow tags to have a manually configured buildmeta section. E.g.: `v4.0.2-dev6+special`.

[1]: https://semver.org/#spec-item-11
[6.6.0]: https://github.com/mdomke/git-semver/compare/v6.6.0...v6.7.0
[6.6.0]: https://github.com/mdomke/git-semver/compare/v6.5.0...v6.6.0
[6.5.0]: https://github.com/mdomke/git-semver/compare/v6.4.0...v6.5.0
[6.4.0]: https://github.com/mdomke/git-semver/compare/v6.3.0...v6.4.0
[6.3.0]: https://github.com/mdomke/git-semver/compare/v6.2.0...v6.3.0
[6.2.0]: https://github.com/mdomke/git-semver/compare/v6.1.1...v6.2.0
[6.1.1]: https://github.com/mdomke/git-semver/compare/v6.1.0...v6.1.1
[6.1.0]: https://github.com/mdomke/git-semver/compare/v6.0.3...v6.1.0
[6.0.3]: https://github.com/mdomke/git-semver/compare/v6.0.2...v6.0.3
[6.0.2]: https://github.com/mdomke/git-semver/compare/v6.0.1...v6.0.2
[6.0.1]: https://github.com/mdomke/git-semver/compare/v6.0.0...v6.0.1
[6.0.0]: https://github.com/mdomke/git-semver/compare/v5.0.0...v6.0.0
[5.0.0]: https://github.com/mdomke/git-semver/compare/v4.0.1...v5.0.0
[4.0.1]: https://github.com/mdomke/git-semver/compare/v4.0.0...v4.0.1
[4.0.0]: https://github.com/mdomke/git-semver/compare/v3.1.1...v4.0.0

repository: ckoehn/git-semver

repo_name: ckoehn/git-semver


text:
# Ledger DApp Ethereum starter kit

Welcome to Ledger DApp starter kit, web app backed by Ethereum smart contract. Out of the box support of Ledger devices and MetaMask.

**bootstrap a project with:**

```
yarn create dapp new-project-name
```

OR

```
npm i -g create-dapp
create-dapp new-project-name
```

![](https://user-images.githubusercontent.com/211411/35970466-b4985312-0cca-11e8-9baf-33e60ec9ac70.gif)

## Pre-requisite documentation to read

* React: https://reactjs.org
* Solidity: https://solidity.readthedocs.io
* web3.js: https://github.com/ethereum/web3.js
* truffle-contract: https://github.com/trufflesuite/truffle-contract

## Pre-requisite tools to install

```
npm install -g truffle ganache-cli
```

## Develop

Run a development Ethereum network:

```
ganache-cli --networkId 1337
```

> Alternatively you can run on Ethereum testnet.

Run the truffle tool, to generate and compile the contracts. **NB: the truffle project lives under src/dapp**

```
cd src/dapp
truffle compile
truffle deploy --network development
```

> Adapt the deploy based on your need. Read truffle documentation for more information.

Run the web app:

```
npm start
```

> Read create-react-app documentation for more information.

repository: obsidiansystems/ledgerjs

branch_name: refs/heads/tezos

gha_language: Nix

repo_name: obsidiansystems/ledgerjs


text:
# PyRat

R-like vectors and functions in Python.

## Warning

This is not Pandas, or scikit-learn, or numpy. This is not R, either. Do not
use this for industry purposes. Do not use this unless you want your project to
break.

Simply have fun with it, or use this for educational purposes.

## Installation

Clone this repository to your local machine with git, then install with Python.

```bash
git clone https://github.com/shanedrabing/pyrat.git
cd pyrat
python setup.py install
```

## Getting Started

Import the libraries with Python.

```python
import pyrat.base
import pyrat.stats
import pyrat.utils
import pyrat.closure
```

The closure library is the only not inspired by R. All other libraries contain
familiar functions. If you want to locate a function within R, look into the
`find` function, determine the namespace, and see if PyRat contains the
function!

## Motivating Examples

So, why use PyRat? If you're a fan of R (like myself), you may have learned
that the capabilities of vectors and functions that operate on them are
immensely powerful.

### Linear Modeling

Let's try modeling a line of best fit between horsepower and miles per gallon
from the `mtcars` dataset:

```python
import matplotlib.pyplot as plt

from pyrat.base import log10, seq
from pyrat.stats import lm, predict
from pyrat.utils import read_csv, struct

df = read_csv("data/mtcars.csv")

x = df["hp"]
y = df["mpg"]

m = lm(log10(x), log10(y))

x_new = seq(min(x), max(x), length_out=101)
y_new = 10 ** predict(m, log10(x_new))

plt.scatter(x, y, color="black")
plt.plot(x_new, y_new, color="red")
plt.xlabel("Horsepower")
plt.ylabel("Miles per Gallon")
plt.tight_layout()
plt.savefig("data/fit.png")
plt.clf()
```

A plot of the fitted linear model:

![data/fit.png](data/fit.png)

### Functional Programming

PyRat has its own version of "piping", whereby the items of a `vector` (or the
`vector` itself) can be continuously operated on. All intermediates are
immutable, as the `vector` is just a `tuple` on steroids.

```python
from pyrat.base import c, paste

taxa = c("Canis lupus", "Felis catus", "Ursidae", "Anura (order)")

print(
    taxa
    .apply("https://en.wikipedia.org/w/index.php?search={}".format)
    .thread(requests.get)
    .apply(getattr, "content")
    .apply(bs4.BeautifulSoup, "lxml")
    .apply(bs4.BeautifulSoup.select_one, "h1")
    .apply(getattr, "text")
    .transform(paste, "(" + taxa + ")", collapse="\n")
)
```

Here's the output:

```txt
Wolf (Canis lupus)
Cat (Felis catus)
Bear (Ursidae)
Frog (Anura (order))
```

repository: shanedrabing/pyrat

repo_name: shanedrabing/pyrat


text:
# **Behavioral Cloning Using a Convolutional Neural Network**

## Goals:
* Use the simulator to collect data of good driving behavior
* Build a convolutional neural network in Keras that predicts steering angles from driving images
* Train and validate the model with a training and validation set
* Test that the model successfully drives around the test track once without leaving the road
* Summarize the results with a written report

[//]: # (Image References)

[image1]: ./examples/cnn-architecture-624x890.png "Model Visualization"
[image2]: ./examples/Centerdriving.png "Center Driving"
[image3]: ./examples/Centerdriving_reversed.png "Center Driving Reversed"
[image4]: ./examples/LeftRecovery.png "Left Recovery"
[image5]: ./examples/RightRecovery.png "Right Recovery"
[image6]: ./examples/center_2018_08_21_15_37_30_274.jpg "Center Cam"
[image7]: ./examples/left_2018_08_21_15_37_30_274.jpg "Left Cam"
[image8]: ./examples/right_2018_08_21_15_37_30_274.jpg "Right Cam"
[image9]: ./examples/center_cropped.jpg "Cropped Cam"

## Rubric Points
Here I will consider the [rubric points](https://review.udacity.com/#!/rubrics/432/view) individually and describe how I addressed each point in my implementation.

---
### Files Submitted & Code Quality

#### 1. Submission includes all required files and can be used to run the simulator in autonomous mode

My project includes the following files:
* model.py containing the script to create and train the model
* drive.py for driving the car in autonomous mode
* model.h5 containing a trained convolution neural network
* README.md summarizing the results

#### 2. Submission includes functional code
Using the Udacity provided simulator and drive.py file, the car can be driven autonomously around the track by executing
```sh
python drive.py model.h5
```

#### 3. Submission code is usable and readable

The model.py file contains the code for training and saving the convolution neural network. The file shows the pipeline I used for training and validating the model, and it contains comments to explain how the code works.

### Model Architecture and Training Strategy

#### 1. An appropriate model architecture has been employed

I used a convolutional neural network with a lambda layer to normalize the data, a cropping layer to reduce noise, 5 convolutional layers with RELU activation functions, a flattening layer, and 4 fully connected layers.

#### 2. Attempts to reduce overfitting in the model

The model was trained and validated on different data sets, and varying epochs to ensure that the model was not overfitting.  I did not need to introduce any dropout to the model. The model was tested by running it through the simulator and ensuring that the vehicle could stay on the track.

#### 3. Model parameter tuning

The model used an adam optimizer, so the learning rate was not tuned manually.  I used 20 epochs as the validation loss was no longer consistently decreasing after that amount.

#### 4. Appropriate training data

Training data was chosen to keep the vehicle driving on the road. I captured two laps each of center lane driving in both directions, and a single lap of recovering from the left and right sides of the road.

### Model Architecture and Training Strategy

#### 1. Solution Design Approach

The overall strategy for deriving a model architecture was to start with an existing model used in autonomous driving. I used the neural network from Nvidia's autonomous driving team as it was already a proven way to autonomously operate a vehicle (and was suggested in the training materials).

In order to gauge how well the model was working, I split my image and steering angle data into a training and validation sets and ran my model in the simulator.  I found that my first model had a _very_ small validation loss (less than 0.01), but only preformed well on staight paths and without hitting the edges of the track.  It was unable to recover from any deviations from center driving.  Instead of making major adjustments to the architecture, I instead augmented the data.  This will be covered more in section 3 below as data collection and augmentation had the biggest impact on my results.

I didn't have any major issues with overfitting, and since Nvidia's network did not contain any dropout, I decided not to introduce it myself.

After augmenting the dataset with enough information, and setting the epochs to an amount where the validation loss leveled out, I reached a reasonable stopping point.

At the end of the process, the vehicle was able to drive autonomously around the track without leaving the road and recover from minor overlaps with the side lane lines/curbs.

#### 2. Final Model Architecture

My final model architecture is based on the convolutional neural network used by the [autonomous driving team at Nvidia](https://devblogs.nvidia.com/deep-learning-self-driving-cars/):

Here is a visualization of the architecture:
![alt text][image1]

#### 3. Creation of the Training Set & Training Process

To capture good driving behavior, I first recorded two laps on track using center lane driving. Here is an example image of center lane driving:

![alt text][image2]

I then recorded the two laps of center lane driving in the opposite direction:

![alt text][image3]

I kept each lap in a separate directory so that I could exclude parts of my full data set if necessary.  Also, as the simulator took some getting used to, I didn't want to contaminate "good" data with any failed runs.

I preprocessed this data by normalizing it (dividing it by 255) and then mean centering it (subtracting 0.5). I then randomly shuffled the data set and put 20% of the data into a validation set.

Here is where my first significant testing began, but the results were not particularly good.  I noticed that the model seemed to only preform well when the vehicle was in the center of the road, which makes sense since that was the only training data it had.  Anytime it encountered an edge or rolled slightly over it, the car would never recover.

To augment the data set with a bit more variety, I added in the left and right angles camera images, and applied a correction of 0.2 to the steering angle to account for location of the camera.  Here is what the 3 different angles look like from the perspective of the car:

**Center:**

![alt text][image6]

**Left:**

![alt text][image7]

**Right:**

![alt text][image8]

I also noticed that certain portions of the track, regardless of track angle, seemed to have strange impacts on the model's chosen steering angle.  I suspected the non-track portions of the image were impacting the learning algorithm. Thus, I also cropped off the top 70 pixels and bottom 25 pixels of the images (as suggested in the training materials) to reduce noise.  Below you can see the center camera image with the cropped area highlighted in red:
![alt text][image9]

After re-training the model, the vehicle could sometimes make it around the track, but again, if any adjustment made by the model steered the vehicle into a barrier too far, it could not recover.  It encountered this scenario on some of the sharper turns.

To combat this, I recorded the vehicle recovering from the left and right sides of the road back to center so that the vehicle would learn to do so if it ever encountered an edge.  These images show what a recovery looks like from both sides:

![alt text][image4]
![alt text][image5]

After this collection process, I had 22,257 total samples (including the 3 camera different angles).

I used this data for training the model. The ideal number of epochs seemed to be 20 as evidenced by a leveling off in validation loss after this point.  I used an adam optimizer so that manually training the learning rate wasn't necessary.  My final validation loss was 0.0221.

This improved my results dramatically, and to some degree (as will be shown below), I could even force the car into a bad situation by taking temporary manual control to drive it onto the curb, and the model would recover.

## Result

### Car Driving a Full Autonomous Lap
Here is the video of the car driving fully autonomously around the track as required by the rubric.  It was created using drive.py and video.py scripts: [video.mp4](video.mp4)

I also made the video available on Youtube at https://youtu.be/NFF8ITAfV18

### Car Recovering from Manual Intervention
In this second video, I manually intervened several times to force the car onto the curb.  In all cases, it recovered.

The first person recorded video wasn't indicative of this as you couldn't see when I had intervened, so I used a local recording and uploaded it here: https://youtu.be/7w8gubrFX44


text:
# Portfolio plugin for [RefineryCMS](http://www.refinerycms.com) ([Github](http://github.com/resolve/refinerycms))

By: [Resolve Digital](http://www.resolvedigital.com)

## Gem Installation

Open your ``Gemfile`` and add this line to the bottom:

    gem 'refinerycms-portfolio', '= 0.9.6', :require => 'portfolio'

Now run ``bundle install`` and once bundler has installed the gem run:

    rake refinery:portfolio:install

..and follow the instructions!

## Plugin Installation

From within your Refinery directory at command line, install this as a plugin using:

    script/plugin install git://github.com/resolve/refinerycms-portfolio.git

Then run:

    rake refinery:portfolio:install

..and follow the instructions!

## Single or Multiple Level Portfolios

The standard setup for portfolios is multi-level, with a parent portfolio having child portfolios.  If your needs are simpler, you can switch to a single level of portfolios by changing the Refinery Setting for 'Multi Level Portfolio' to false.

repository: ashrafuzzaman/stips

repo_name: ashrafuzzaman/stips


text:
[![Build Status](https://travis-ci.org/sotanodroid/GO_API.svg?branch=master)](https://travis-ci.org/sotanodroid/GO_API) [![codecov](https://codecov.io/gh/sotanodroid/GO_API/branch/master/graph/badge.svg)](https://codecov.io/gh/sotanodroid/GO_API) [![reliability rating](https://sonarcloud.io/api/project_badges/measure?project=sotanodroid_GO_API&metric=reliability_rating)](https://sonarcloud.io/dashboard?id=sotanodroid_GO_API) [![security rating](https://sonarcloud.io/api/project_badges/measure?project=sotanodroid_GO_API&metric=security_rating)](https://sonarcloud.io/dashboard?id=sotanodroid_GO_API)

# Simple GOLang REST API

> Simple RESTful API to create, read, update and delete books.

gha_language: Go


text:
---
title: "contentType: getCompatibleHubContentTypes"
description: "Get a list of compatible content types from the content type hub that can be added to a target site or a list."
author: "swapnil1993"
ms.localizationpriority: medium
ms.prod: "sites-and-lists"
doc_type: apiPageType
---

# contentType: getCompatibleHubContentTypes
Namespace: microsoft.graph

Get a list of compatible content types from the content type hub that can be added to a target [site](../resources/site.md) or a [list](../resources/list.md).

This method is part of the content type publishing changes to optimize the syncing of published content types to sites and lists, effectively switching from a "push everywhere" to "pull as needed" approach. The method allows users to pull content types directly from the content type hub to a site or list. For more information, see [contentType: addCopyFromContentTypeHub](contenttype-addcopyfromcontenttypehub.md) and the blog post [Syntex Product Updates – August 2021](https://techcommunity.microsoft.com/t5/sharepoint-syntex-blog/syntex-product-updates-august-2021/ba-p/2606438).

## Permissions
One of the following permissions is required to call this API. To learn more, including how to choose permissions, see [Permissions](/graph/permissions-reference).

|Permission type|Permissions (from least to most privileged)|
|:---|:---|
|Delegated (work or school account) | Sites.Manage.All, Sites.FullControl.All |
|Delegated (personal Microsoft account) | Not supported.    |
|Application | Sites.Manage.All, Sites.FullControl.All |

## HTTP request

<!-- {
  "blockType": "ignored"
}
-->
``` http
GET /sites/{siteId}/lists/{listId}/contentTypes/getCompatibleHubContentTypes
GET /sites/{siteId}/contentTypes/getCompatibleHubContentTypes
```

## Request headers
|Name|Description|
|:---|:---|
|Authorization|Bearer {token}. Required.|

## Request body
Do not supply a request body for this method.

## Response

If successful, this function returns a `200 OK` response code and a collection of [contentType](../resources/contenttype.md) objects in the response body.

## Examples

### Request

The following is an example of a request.

# [HTTP](#tab/http)
<!-- {
  "blockType": "request",
  "name": "contenttype_getcompatiblehubcontenttypes",
  "sampleKeys": ["root", "Documents"]
}
-->
``` http
GET https://graph.microsoft.com/v1.0/sites/root/lists/Documents/contentTypes/getCompatibleHubContentTypes
```

# [C#](#tab/csharp)

```csharp

GraphServiceClient graphClient = new GraphServiceClient( authProvider );

var getCompatibleHubContentTypes = await graphClient.Sites["{site-id}"].Lists["{list-id}"].ContentTypes
	.GetCompatibleHubContentTypes()
	.Request()
	.GetAsync();

```

 For details about how to [add the SDK](/graph/sdks/sdk-installation) to your project and [create an authProvider](/graph/sdks/choose-authentication-providers) instance, see the [SDK documentation](/graph/sdks/sdks-overview).

### Response

The following is an example of the response.

>**Note:** The response object shown here might be shortened for readability.
<!-- {
  "blockType": "response",
  "truncated": true,
<EMAIL_ADDRESS>"microsoft.graph.contentType",
  "isCollection": true
}
-->
``` http
HTTP/1.1 200 OK
Content-Type: application/json

{
  "value": [
    {
<EMAIL_ADDRESS>"#microsoft.graph.contentType",
      "id": "0x0101",
      "description": "Document content type",
      "group": "Document Content Types",
      "hidden": false,
      "isBuiltIn": true,
      "name": "Document"
    }
  ]
}
```

repository: microsoftgraph/msgraph-sdk-dotnet

branch_name: refs/heads/dev

gha_language: C#

gha_license_id: NOASSERTION

repo_name: microsoftgraph/msgraph-sdk-dotnet


text:
---
layout: kanji
v4: 1590
v6: 1715
kanji: 念
keyword: wish
elements: wish, now, clock, heart
strokes: 8
image: E5BFB5
on-yomi: ネン
permalink: /rtk/念/
prev: 吟
next: 捻
---

1) [raulir] 8-4-2007(214): Someone wishing from the bottom of their heart that the clock would stop. A mid-life crisis perhaps.

2) [shaydwyrm] 28-6-2007(87): Remember in the Wizard of Oz when the tin man wished for a heart and the wizard gave him that dinky little clock instead?

3) [BlackMarsh] 16-2-2006(61): A wish is something that your heart desires right now.

4) [QuackingShoe] 6-7-2008(46): I wish with all my heart that I knew all the kanji now. This studying sucks!

5) [jabberwockychortles] 12-1-2010(17): I wish the clock would give me more time to do the things that my heart desires the most.


text:
# silk-camera-facedetect
Demo of basic face detection using Silk

# Usage
1. Flash the Kenzo device with the latest Silk platform
2. `silk run` this program
3. When the face is detected, the camera frame will be saved to `/data/faces.png` on device.  Use `adb pull /data/faces.png` to retrieve it

license: Unlicense

repository: mvines/silk-camera-facedetect

repo_name: mvines/silk-camera-facedetect


text:
pCRP - Google App Engine-based conference management
====================================================

pCRP is a web app for managing conference paper uploads and reviews. pCRP
is inspired by Eddie Kohler's [HotCRP][1], but is easier to set up and manage
because it runs on Google App Engine, rather than your own Linux server, PHP
runtime, and MySQL server.

All you have to do to set up is run [deps.py](deps.py) and then follow
[Google's instructions for deploying a GAE app][2]. More detailed instructions
can be found in [docs/manual.tex] (docs/manual.tex).

pCRP is licensed under [Version 2.0 of the Apache License](LICENSE).

[1]: http://www.read.seas.harvard.edu/~kohler/hotcrp/
[2]: https://cloud.google.com/appengine/docs/python/tools/uploadinganapp#Python_Uploading_the_app

repository: JustinLardinois/pcrpdev

repo_name: JustinLardinois/pcrpdev


text:
# JDBC engine usage documentation

This article mainly introduces the configuration, deployment and use of JDBC engine in Linkis1.0.

## 1. Environment configuration before using the JDBC engine

If you want to use the JDBC engine on your server, you need to prepare the JDBC connection information, such as the connection address, user name and password of the MySQL database, etc.

## 2. JDBC engine configuration and deployment

### 2.1 JDBC version selection and compilation

The JDBC engine does not need to be compiled by the user, and the compiled JDBC engine plug-in package can be used directly. Drivers that have been provided include MySQL, PostgreSQL, etc.

### 2.2 JDBC engineConn deployment and loading

Here you can use the default loading method to use it normally, just install it according to the standard version.

### 2.3 JDBC engine tags

Here you can use the default dml.sql to insert it and it can be used normally.

## 3. The use of JDBC engine

### Ready to operate

You need to configure JDBC connection information, including connection address information and user name and password.

![](../Images/EngineUsage/jdbc-conf.png)

Figure 3-1 JDBC configuration information

### 3.1 How to use Scriptis

The way to use Scriptis is the simplest. You can go directly to Scriptis, right-click the directory and create a new JDBC script, write JDBC code and click Execute.

The execution principle of JDBC is to load the JDBC Driver and submit sql to the SQL server for execution and obtain the result set and return.

![](../Images/EngineUsage/jdbc-run.png)

Figure 3-2 Screenshot of the execution effect of JDBC

### 3.2 How to use workflow

DSS workflow also has a JDBC node, you can drag into the workflow node, then double-click to enter and edit the code, and then execute it in the form of a workflow.

### 3.3 How to use Linkis Client

Linkis also provides a client way to call JDBC tasks, the way to call is through the SDK provided by LinkisClient. We provide java and scala two ways to call, the specific usage can refer to <https://github.com/WeBankFinTech/Linkis/wiki/Linkis1.0%E7%94%A8%E6%88%B7%E4 %BD%BF%E7%94%A8%E6%96%87%E6%A1%A3>.

## 4. JDBC engine user settings

JDBC user settings are mainly JDBC connection information, but it is recommended that users encrypt and manage this password and other information.

repository: yangzhiyue/Linkis-Doc

repo_name: yangzhiyue/Linkis-Doc


text:
---
layout: "unit"
title: "Guide Entry to 88.04.02"
path: "/curriculum/guides/1988/4/88.04.02.x.html"
unitTitle: "Translation Into Reality"
unitAuthor: "Anthony F. Franco"
keywords: "Twentieth Century Short Story Adolescence American Literature Journals Writing Instruction"
recommendedFor: "Recommended for English classes, grades 7-12"
---

Guide Entry to 88.04.02:

“Translation Into Reality” is a multi-dimensional unit that focuses upon quality American short fiction with themes of great relevance for inner city students. Themes such as suicide, alcohol, or drug abuse, sexual awareness, and parent-child relationships are found in each selection. Aseries of class discussion questions for each of the ten stories in the unit follow a short synopsis of the story and the reasons for its inclusion. The class discussion questions are also designed to illustrate several fundamental aspects of the short story including character, setting, and point of view.

Once students have read the story and participated in the class discussion, they will attempt to write short reactions to the story and the discussion. Various writing suggestions have been included for this purpose. “Translation Into Reality” brings relevant reading matter to inner city students, teaches several elements of the short story, encourages students to express their own opinions, and provides for students to develop their writing skills while understanding that the problems they face on a daily basis can be overcome.

(Recommended for English classes, grades 7-12)

Key Words

Twentieth Century Short Story Adolescence American Literature Journals Writing Instruction

gha_language: HTML


text:
# Alpine + Gcloud + Helm + Helm-Deployer

This image is based on the [alpine:latest](https://hub.docker.com/_/alpine/) image. On top of this, it has `gcloud`, `kubectl`, and `helm` CLI tools installed.

There are additional shell scripts to check the install, log you into gcloud via the SDK.

## Helm Deployer Go Application
This app also pulls in the [hutchison-t/helm-deployer](https://github.com/Hutchison-Technologies/helm-deployer) image from github, and builds it within the docker image, making the gcloud_helm_deploy cli go application available.

If you wish to modify our GreenBlue deploy process, please modify this go service. Once happy with the changes, you'll need to rebuild this image locally.

To build, please build with a --no-cache and --platform linux/amd64 flag like:
```
➜ docker build . --no-cache --platform linux/amd64
```

No-cache is required to ensure that we pull in the latest Go "helm deployer" application.
--platform flag is required to ensure we build for GKE compatible architecture AMD64 rather than ARM, if this is not set then you will see issues in the workflow when delegating agents for jenkins steps, the specific error of the container will be like `standard_init_linux.go:228: exec user process caused: exec format error`

After the build is complete, (this may take a while) tag it like:
```
➜ docker tag *imageID* hutchisont/helm-deployer:latest
```

Once tagged, push to dockerhub via:
```
➜ docker push hutchisont/helm-deployer
```

Any jenkins builds which reference this docker image (almost all of them) will now pull in this updated docker image by default.

If you wish to modify Helm Charts and not the deploy process, modify the charts at the repository [hutchison-t/helm-charts](https://github.com/Hutchison-Technologies/helm-charts).

repository: Hutchison-Technologies/docker-images

repo_name: Hutchison-Technologies/docker-images


text:
# SourceAutoRecord

[![](docs/img/sar_logo.webp)](https://sar.portal2.sr/)

[![CI](https://github.com/p2sr/SourceAutoRecord/workflows/CI/badge.svg)](https://github.com/p2sr/SourceAutoRecord/actions?query=workflow%3ACI+branch%3Amaster)
[![CD](https://github.com/p2sr/SourceAutoRecord/workflows/CD/badge.svg)](https://github.com/p2sr/SourceAutoRecord/actions?query=workflow%3ACD+branch%3Amaster)
[![Latest release](https://img.shields.io/github/v/release/p2sr/SourceAutoRecord?label=latest%20release)](https://github.com/p2sr/SourceAutoRecord/releases/latest)
[![Latest prerelease](https://img.shields.io/github/v/release/p2sr/SourceAutoRecord?label=latest%20pre-release&include_prereleases)](https://github.com/p2sr/SourceAutoRecord/releases)
[![License](https://img.shields.io/github/license/p2sr/SourceAutoRecord)](https://github.com/p2sr/SourceAutoRecord/blob/master/LICENSE)

### [Overview](#overview) | [Support](#support) | [Documentation](#documentation)

# Overview

**SourceAutoRecord** (**SAR**) is a plugin for Portal 2 and mods based on it, bringing lots of features and modifications
into the game for speedrunners and people alike.

For features and installation instructions, please visit [the website].

[the website]: https://sar.portal2.sr/

# Support

| Game                                                                    | Windows | Linux |
|-------------------------------------------------------------------------|---------|-------|
| [Portal 2](https://store.steampowered.com/app/620)                      | ✔       | ✔     |
| [Aperture Tag](https://store.steampowered.com/app/280740)               | ✔       | ✔     |
| [Portal Stories: Mel](https://store.steampowered.com/app/317400)        | ✔       | ✔     |
| [Thinking with Time Machine](https://store.steampowered.com/app/286080) | ✔       | ✔     |
| [Portal Reloaded](https://store.steampowered.com/app/1255980)           | ✔       | ✔     |

# Documentation
- [Contributing](docs/contributing.md)
- [Console Commands & Variables](docs/cvars.md)
- [Setup & Usage](https://wiki.portal2.sr/SAR)

repository: Gaubbe/SourceAutoRecord

repo_name: Gaubbe/SourceAutoRecord


text:
# DbTargetDetails

DbTargetDetails

## Properties

Name | Type | Description | Notes
------------ | ------------- | ------------- | -------------
**dbHostName** | **String** |  |  [optional]
**dbName** | **String** |  |  [optional]
**dbPort** | **String** |  |  [optional]
**dbPrivateKey** | **String** | (Optional) Private Key in PEM format |  [optional]
**dbPrivateKeyPassphrase** | **String** |  |  [optional]
**dbPwd** | **String** |  |  [optional]
**dbServerCertificates** | **String** | (Optional) DBServerCertificates defines the set of root certificate authorities that clients use when verifying server certificates. If DBServerCertificates is empty, TLS uses the host's root CA set. |  [optional]
**dbServerName** | **String** | (Optional) ServerName is used to verify the hostname on the returned certificates unless InsecureSkipVerify is given. It is also included in the client's handshake to support virtual hosting unless it is an IP address. |  [optional]
**dbUserName** | **String** |  |  [optional]
**sfAccount** | **String** |  |  [optional]
**sslConnectionCertificate** | **String** | (Optional) SSLConnectionCertificate defines the certificate for SSL connection. Must be base64 certificate loaded by UI using file loader field |  [optional]
**sslConnectionMode** | **Boolean** | (Optional) SSLConnectionMode defines if SSL mode will be used to connect to DB |  [optional]

repository: akeylesslabs/akeyless-java

gha_language: Java

repo_name: akeylesslabs/akeyless-java


text:
# HTML Paragraphs
HTML documents are divided into paragraphs.
## HTML paragraphs
```html
The HTML <p> element defines a paragraph.
```
###Example
```html
<p>This is a paragraph</p>
<p>This is another paragraph</p>
```
####[Try yourself] (http://www.w3schools.com/html/tryit.asp?filename=tryhtml_paragraphs1)
```html
Note Browsers automatically add some white space before and after a paragraph.
```
##HTML Display
```html
You cannot be sure how HTML will be displayed.
Large or small screens, and resized windows will create different results.
With HTML, you cannot change the output by adding extra spaces or extra lines in your HTML code.
The browser will remove extra spaces and extra lines when the page is displayed.
Any number of spaces, and any number of new lines, count as only one space.
```
###Example
```html
<p>
This paragraph
contains a lot of lines
in the source code,
but the browser
ignores it.
</p>
<p>
This paragraph
contains a lot of spaces
in the source code,
but the browser
ignores it.
</p>
```
####[Try yourself] (http://www.w3schools.com/html/tryit.asp?filename=tryhtml_paragraphs2)
##Don't Forget the End Tag
Most browsers will display HTML correctly even if you forget the end tag:
###Example
```html
<p>This is a paragraph
<p>This is another paragrap
```
####[Try yourself] (http://www.w3schools.com/html/tryit.asp?filename=tryhtml_paragraphs0)
The example above will work in most browsers, but do not rely on it.
Forgetting the end tag can produce unexpected results or errors.

Note Stricter versions of HTML, like XHTML, do not allow you to skip the end tag.
##HTML Line Breaks
```html
The HTML <br> element defines a line break.
Use <br> if you want a line break (a new line) without starting a new paragraph:
```
###Example
```html
<p>This is<br>a para<br>graph with line breaks</p>
```
####[Try yourself] (http://www.w3schools.com/html/tryit.asp?filename=tryhtml_paragraphs)
```html
The <br> element is an empty HTML element. It has no end tag.
```
##The Poem Problem
This poem will display as one line:
###Example
```html
<p>
My Bonnie lies over the ocean.
My Bonnie lies over the sea.
My Bonnie lies over the ocean.
Oh, bring back my Bonnie to me.
</p>
```
####[Try yourself] (http://www.w3schools.com/html/tryit.asp?filename=tryhtml_poem)
##The HTML ```<pre>``` Element
```html
The HTML <pre> element defines preformatted text.
The text inside a <pre> element is displayed in a fixed-width font (usually Courier), and it preserves both spaces and line breaks:
```
###Example
```html
<pre>
My Bonnie lies over the ocean.
My Bonnie lies over the sea.
My Bonnie lies over the ocean.
Oh, bring back my Bonnie to me.
</pre>
```
####[Try yourself] (http://www.w3schools.com/html/tryit.asp?filename=tryhtml_pre)


text:
# 0.1.0 (2016-02-23)

#### Features

- **Based off chentsulin's boilerplate**
- **Basic editor functions** - open, create, save
- **Cached editing** - unsaved changes persist on restart
- **Spellcheck** - inconsistent and broken
- **Inline Maths** - partial support

repository: will-hart/vor

repo_name: will-hart/vor


text:
# Changelog

All notable changes to this project will be documented in this file.
All changes are from [@nickgerace](https://github.com/nickgerace) unless otherwise specified.

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]

The latest version contains all changes.

## [0.1.0] - 2021-04-19

### Added

- `DEVELOPING.md` file
- `RELEASE.md` file
- `rustfmt.toml` file for automatic changes that would have been enforced manually
- Base contents
- Description and example output to README
- Elements from `lib.rs` before the removal of `watcher.rs`
- Loop for watcher in case timeouts occur
- Security considerations to README
- Two Docker Hub tags: `unstable` for users and `broken` for development

### Changed

- `ekidd/rust-musl-builder` to `clux/muslrust` due to smaller, final binary sizes and newer Rust base images
- `env_logger` location from `main.rs` to `lib.rs`, and then back to `main.rs` (best used in an application; not a libary)
- `eyre` to `anyhow` since we only needed the `Result` type from the crate for basic error reporting
- `kube::api::Meta` to `kube::api::Resource` due to deprecation
- Combined `lib.rs` and `watcher.rs` functions to reduce runtime complexity
- Combined use statements in each file
- Hasher to only be created once during add events
- Kubernetes client creation to `main.rs` and out of the library entirely
- Name from "image-logger" to "cluster-imager-logger" to "kimager"
- Names in Helm chart to be hardcoded to "kimager"
- RBAC in Helm chart into different files

### Removed

- `watcher.rs` in favor of using `lib.rs` for the watcher loop
- File header comments
- Module path from `env_logger` output

repository: nickgerace/kimager

repo_name: nickgerace/kimager


text:
---
name: Bug
about: Create a report to help us improve
labels: "bug"
---

**Describe the bug**

- TBA

**Screenshots**

- TBA

**To Reproduce**

Steps to reproduce the behavior:

1. Go to '...'
1. Click on '....'
1. Scroll down to '....'
1. See error

**Expected behavior**

- [ ] TBA

**Smartphone (please complete the following information):**

- Device: [e.g. iPhone6]
- OS: [e.g. iOS8.1]
- Browser [e.g. stock browser, safari]
- Version [e.g. 22]

**Additional context**

- TBA

gha_language: TypeScript


text:
# Bookmark Service Application

An insecure spring boot based java service providing an API to store and retrieve browser bookmarks for different users.

* __main__ branch: The insecure variant of this application with lots of security tests covering several topics of the OWASP Top 10 (2017), and the OWASP ASVS 4.x (only secured via basic authentication and form based login without any authorization checks)

* __secure__ branch (planned): The secure variant (all security tests should be green). Still using basic authentication and form based login, but including authorization checks.

* __jwt__ branch (planned): Another secure variant (same as in __secure__ branch but replacing basic authentication/form login with JWT based authentication & authorization)

## Security Tests

The security tests include the following types:

* Unit Test Layer
  * Static Code Analysis using SpotBugs & SonarQube (both using the respective Gradle Plugins)
  * OWASP Dependency Check
  * Security Architecture Tests (ArchUnit)
  * Input Validation Tests
  * Broken Authentication Tests
* Integration Test Layer
  * Security Misconfiguration Tests
  * Injection (SQL Injection) Tests
  * Broken Access Control Tests
* UI/Workflow Layer
  * Dynamic Security Tests using OWASP Zap

repository: MSCheckPoint/bookmark-service-main

repo_name: MSCheckPoint/bookmark-service-main


text:
# NoonExcelReader
  Custom made library to reads excel files and directly converts table rows to objects.

## Methods
### Read Files to List<List<string>>
  You can read a file to a nested list of strings holding all the values, so you can loop through them if you'd like

  > public static List<List<string>> Read(string path);
  > path: provide only the path of the file you want to read.
  > returns: List<List<string>>, each list represents a row in your table, each item in that list represents a column in your row.

### Read Files Directly to objects of a class
  Read excel file to a class represeting a row in your table.

  > public static List<T> ReadConvert<T>(string path);
  > path: provide only the path of the file you want to read.
  > returns: T class to map table to, check the following example:

  #### Excel table

  > Name | Title | Department
  > -----|-------|------------
  > Noon | Dr | IT
  > Ahmed | Mr | Arch
  > Samar | Mrs | Eng

  #### Class to map to
  ```c#
  public class Person
    {
        public string Name { get; set; }
        public string Title { get; set; }
        public string Department { get; set; }
    }
  ```

  #### Usage
  ```c#
  NoonExcelReader.ReadConvert<Person>("e:/exceltext.xlsx");
  ```

  > Result will be List of Person

  * Limitations
    * For now, library only reads string values, therefore it will map only string values, next version will hopefully have this feature.

    Feel free to contact me for any questions.

repository: NoonBenbraik/NoonExcelReader

repo_name: NoonBenbraik/NoonExcelReader


text:
## Templates

The event collector uses Go's template library (text/template) to parse the provided template. The result is the payload sent to Telegraf using a POST operation.

The events are expected in JSON format. Two custom functions that are provided to faciliate the extraction of data from the event regardless of its JSON schema:  ```keyAndValueFromJSONKey``` and ```valueFromJSONKey```.

Given the following JSON payload:

```json
{
    "band":"pearl jam",
    "genre":"alternative",
    "members":[
        {"vocals": {
            "name":"Eddie",
            "lastname":"Vedder"
            }},
        {"leadguitar":"Mike"},
        {"guitar":"Stone"},
        {"drums":"Matt"}
    ]
}
```

And the template:

 ```bash
 two-members: {{ valueFromJSONKey "members.vocals.name" }}, {{ valueFromJSONKey "members.leadguitar" }}
 ```

The resulting payload would be:

```bash
two-members: Eddie, Mike
```

If the field name is needed to create a key value list, you can use ```keyAndValueFromJSONKey```.

```bash
 two-members: {{ keyAndValueFromJSONKey "members.guitar" "=" }}, {{ keyAndValueFromJSONKey "members.drums" "=" }}

```

Will result on:

```bash
two-members: guitar=Stone, drums=Matt
```

repository: BCDevOps/openshift-tools

repo_name: BCDevOps/openshift-tools


text:
# @devtools-ds/object-inspector

An emulation of the Chrome and Firefox object inspector, which allows you to view JavaScript objects in the console.

## Installation

```sh
npm i @devtools-ds/object-inspector
# or with yarn
yarn add @devtools-ds/object-inspector
```

## Supported Types

JavaScript has a broad and sometimes complicated [set of available types](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects). This component attempts to display most types nicely, and we have styles for the following:

```ts
export type SupportedTypes =
  | boolean
  | null
  | number
  | string
  | Error
  | symbol
  | undefined
  | Date
  | RegExp
  | object
  | Map<any, any>
  | WeakMap<any, any>
  | Set<any>
  | WeakSet<any>
  | Promise<any>
  | any[]
  | Function;
```

For types it doesn't know about, the component should try to find a name or string to display.

## Usage

Then to use the component in your code just import it!

```js
import { ObjectInspector } from "@devtools-ds/object-inspector";

const data = {
  string: "string",
  boolean: true,
  number: 100,
};

<ObjectInspector data={data} expandLevel={1} sortKeys={true} />;
```

## Callbacks

`onSelect`

This function is called with the selected AST node (after parsing the `data` prop with `@devtools-ds/object-parser`). With the selected node, you're able to traverse up/down the tree, and act on the currently selected node (like displaying additional details about that property).

## FAQ

### Why is [insert type] type not supported better?

Some types like `WeakSet`, `WeakMap`, etc. cannot be easily inspected using the JavaScript APIs. Promises are similar, although there is a workaround using `Promise.race` that forces most things in this component to be asynchronous. The reason they work nicely in the browsers is because they have access to the JavaScript engine APIs which gives them a lot more control.

If you see a type that is missing and easy to support, feel free to open an issue or PR to add it.

### Why does [insert property] property not always match my browser?

I had a goal with this project to look at both the Chrome and Firefox inspectors to ideally support theming based on browser. Sometimes things couldn't be themed simply between the two and compromises were made. For example Chrome mixes a double underscore syntax like `__proto__` with a double bracket syntax like `[[Entries]]`. Firefox is much more consistent with a `<prototype>` and `<entries>` syntax so I decided to stick with that. There were some compromises in both directions for consistency.

I'm open to suggestions on ways this can be improved.

### Why is [insert property] color slightly different?

For the most part, the colors should be near identical to the browser implementations.

Sometimes there were complicated colors across browsers, where one might take three colors to do what the other does in one. These were basically evaluated case-by-case looking at the added complexity. Sometimes browsers had colors that were really light and had really bad contrast. In the interest of accessibility I sometimes left these a bolder color.

## Useful References

- [MDN Object Types](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects)
- [MDN Typed Arrays](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Typed_arrays)

## Contributors ✨

Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):

Tyler Krupicka
💻 📖 🎨 🚇 💡 ⚠

Adam Dierkens
💻 📖 💡 ⚠

This project follows the [all-contributors](https://github.com/all-contributors/all-contributors) specification. Contributions of any kind welcome!

repository: nksaraf/devtools-ds

repo_name: nksaraf/devtools-ds


text:
# Fisp

Modern HTTP **F**ile **I**ndexer for **S**tatic **P**age.

![Icon](images/logo.png)

This project is use for static page hosting file indexer, such as github pages.
Demo: [https://samuel.nctu.me/fisp](https://samuel.nctu.me/fisp)

![Screenshot](images/demo.png)

## Getting Started

These instructions will get you a copy of the project up and running on your local machine for development and testing purposes. See deployment for notes on how to deploy the project on a static page.

### Prerequisites
- Your files
- Static page hosting service (ex. Github Pages)

### Installation
Copy `index.html` to every folder,
and generate `file.json` in every folder. (Instructions in [usage](#usage))

## Running the tests
It's suggested that testing this project with a file hosting server. Due to CORS policy, the website can't fetch `file.json` with XMLHttpRequest if simpily open `index.html` from file explorer.
For example, use a python simple HTTP server:
`$ python -m SimpleHTTPServer`

## Usage
After copied `index.html` to every folder, we need `file.json` in every folder too, in order make it be able to recognize which files is located in this directory.
The file `file.json` is an array, consisting different objects, each representing a file or folder. It may look like this:
```json
[
    {"type": "folder",
     "name": ".."},
    {"type": "word",
     "name": "Word.docx"},
    {"type": "ppt",
     "name": "presentation.pptx"}
]
```
Every objects have two data, *type* and *name*, if the *type* is one of the following one, webpage will display a specific icon, otherwise, it'll display *file* icon.

| Type | Icon |
| ------ | ----------- |
| word |  |
| ppt |  |
| excel |  |
| video |  |
| pdf |  |
| image |  |
| code |  |
| audio |  |
| file |  |
| folder |  |

See [docs](docs) for more details about `file.json`.

## Todo
 - [ ] Write `file.json` generator.

## Built With

* HTML 5 and CSS 5
* [FontAwesome](https://fontawesome.com/) - File types icons.

## Author

* [Samuel Huang (黃恩明)](https://samuel.nctu.me)

## License

This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details


text:
# Installing and configuring the Microsoft Azure Storage Explorer

The Microsoft Azure Storage Explorer is a convenient Windows application that you can use to explore your queues, blobs, file shares and databases in your Azure subscription. This very convenient tool allows you to create new storage accounts, inspect all your data to find issues, make sure that everything is working properly etc.

You can install [from this website](https://azure.microsoft.com/en-us/features/storage-explorer/). After you install the tool on your development machine, start the explorer.

![Microsoft Azure Storage Explorer](/Doc/Img/azure-explorer/2017-09-06_13-31-45.png)

1. Click on "Add an account".

2. Select Azure from the combobox in the "Connect to Azure Storage" window, unless the account you want to use is stored elsewhere. Then press "Sign in".

![Connect to Azure Storage](/Doc/Img/azure-explorer/2017-09-06_13-37-02.png)

3. Enter your account details. In case you still don't have an Azure account and an active subscription, [you can follow the steps here](trial-account.md).

4. In the Microsoft Azure Storage Explorer's main window, you should now see the subscriptions for your account. If you have followed the instructions to get a free trial subscription, you should now see it.

> **Note:** If you don't see your subscription, make sure that the Microsoft Azure Storage Explorer window is maximized.

![Subscription in the Azure Explorer](/Doc/Img/azure-explorer/2017-09-06_14-01-00.png)

5. You can now explore your data.

![Data view in the Azure Explorer](/Doc/Img/azure-explorer/2017-09-06_14-10-50.png)

repository: jkeurix/sample-azure-general

repo_name: jkeurix/sample-azure-general


text:
![](./images/LOGO.png)

# Embedded Machine Learning
![](./images/Music_Box_outside.png)

The Music Box is stand-alone platform built around the Beaglebone Black
to record live music and classify the instrument that is playing in real-time.
The software is able to receive input with an integrated button, record
audio clips using an integrated mic, and display the resulting classification
in seconds with an integrated LCD screen. This is all housed neatly in a 3D
printed case.

## Table of Contents
* [Hardware](#hardware)
  - [Beagelbone Black](#bbb)
  - [Button](#button)
  - [Mic](#mic)
  - [1602A LCD](#lcd)
  - [3D Printed Parts](#case)
  - [Post Wiring](#finished)
* [Software](#software)
* [Built With](#built)
* [Authors](#authors)

## Hardware

![](./images/BOM.png)

### Beaglebone Black
![](./images/BBB_SoC.jpg)
* The Beagle Bone Black (BBB) was utilized as this projects embedded platform.

### Tactile Button
![](./images/Button.jpg)
* A tactile button was integrated for user input.
* Pins used for Button:
  - Button Data = P8[17]
  - Button 3V = P9[3]
  - Button GND = P9[1]

### Microphone
![](./images/Mic.jpg)
* A microphone was integrated for audio input.

### LCD Screen
![](./images/LCD.png)
* A 1602A LCD screen was integrated for user output.
* Pins used for LCD:
  - LCD Data = P8[12, 14, 16, 18]
  - LCD 5V = P9[8]
  - LCD GND = P9[2]

### 3D Printed Parts
* A 3D Printed case was made to house the components
  - ![](./images/Case.jpg)
* A 3D Printed bridge was made to support the button
  - ![](./images/Bridge.png)

### Post Wiring

* This is the result of soldering all the components and wiring them
 to the BBB
  - ![](./images/Music_Box_inside.jpg)

## Software

* The main program, main.py, connects to the USB mic and prompts the user
to press the button to start recording.
* When the button is pressed, an audio stream is opened up and the user is
prompted to press the button to stop recording.
* The program will record audio samples into a buffer until the button is pressed.
* After the button is pressed a second time, the file is:
  - filtered
  - processed
  - converted to a .wav file
  - passed into the Support Vector Machine model
* The resulting instruments are displayed on the LCD screen.

## Built With
* [Adafruit Char LCD](https://github.com/adafruit/Adafruit_Python_CharLCD/blob/master/Adafruit_CharLCD/Adafruit_CharLCD.py) -
this is used to interface with the 1602A LCD screen
* [Adafruit BBIO](https://pypi.org/project/Adafruit_BBIO/) - this is used to interface
 with the Beaglebone Black's GPIO pins
* [PyAudio](https://pypi.org/project/PyAudio/) - this is used to handle our audio I/O
* [DateTime](https://pypi.org/project/DateTime/) - this is used to add dates and times
to recorded audio file's names
* [Wave](https://pypi.org/project/Wave/) - this is used for audio file processing, setting
sample rates, setting channels, and setting sample size
* [Pickle](https://docs.python.org/3/library/pickle.html#module-pickle) - this is used to convert the
Machine Learning model into a byte stream to be saved to disk
* [LibROSA](https://librosa.github.io/librosa/index.html) - this is used for audio
analysis, trimming, onset detection, and collecting the [Mel-frequency Cepstrum Coefficients (MFCC)](https://en.wikipedia.org/wiki/Mel-frequency_cepstrum)
* [NumPy](https://www.numpy.org) - this is used for manipulating the MFCC values
* [Scikit Learn](https://scikit-learn.org/stable/modules/svm.html) - this is used for the Support Vector Machine
supervised learning model for classification of musical instruments
* [1602A LCD Case](https://www.thingiverse.com/thing:1873666) - this was used to house the hardware
* [Button Bridge](https://www.thingiverse.com/thing:1277483) - this was used to hol up the button inside the case

## Authors
* **Daniel Salazar**
  - Hardware Analysis, Integration, and Soldering
  - 3D Printing
  - LCD Software
  - Machine Learning model selection, analysis, and training/testing

* **Thomas Martin**
  - Mic Software
  - Audio Preprocess Software
  - Button Software
  - Conversion of Machine Learning model to the embedded version and
  training/testing
## License

This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details

## Acknowledgments

* Hat tip to Adafruit for providing the hardware driver code
* Thanks to [Rodger Doering](http://www.csueastbay.edu/directory/profiles/engr/doeringroger.html)
for his insight into the intricacies of Digital Signal Processing.
* Thanks to [Inés  Thiebaut](https://www.csueastbay.edu/directory/profiles/mus/thiebautines.html)
for her insight into Musical Instrument Classification.


text:
# Explore UK Crime Data with Pandas and Geopandas

In this workshop you will learn how to expand your Python data analysis skills to geospatial data. The workshop is aimed at people who are interested in data science and data analysis.

During the workshop we will analyse UK Crime Data with Pandas and GeoPandas in a Jupyter notebook. We first will look at the properties of geospatial data and explore the different commands. After you have learned the basics we will go through some exercises analysing the UK Crime Data to explore patterns and trends and create a few maps of crime rates in London.

## Environment Setup

In this workshop we will use IBM Watson Studio to run a notebook. For this you will need an IBM Cloud account to provision an instance of Watson Studio and Cloud Object Storage. If you do not have a Watson Studio service already provisioned, follow the steps outlined in these [instructions](https://github.com/jrtorres/dsai-workshop-dataprocessing/blob/master/SetupWatsonStudio.md)

### Store this repository on your local computer.

   If you have GIT on your machine, clone this repository locally. Open a terminal and run:

   ```
   $ git clone https://github.com/jrtorres/geopandas-workshop.git
   ```

   If you do NOT have GIT on your machine, you can just download the repository as a ZIP file. From the browser, select the "Download as Zip" option (_Note: The screenshot may show a different respository name, make sure you are downloading the correct repository_):

   ![Download Repo](images/ss0.png)

## Load Notebook in Watson Studio

### 1. Create a new Project

- You should now be in Watson Studio (http://dataplatform.ibm.com)
- Create a new project by clicking on `Get Started` and `New Project`, or `Create Project`
- Give your Project a name.
- Select an Object Storage from the drop-down menu. This is used to store the notebooks and data.
- click `Create`.

* If no Storage is listed, add a new Data Storage,

	![](../images/project-add-storage.png)

  * Click the `Add` link to define object storage for the project,
  * A new window or tab will open to create Cloud Object Storage,
  * Select the `Lite` option,
  * Click `Create`,
  * Select the `default` for `Resource group`,
  * For `Service name` enter a name, e.g. `<username>-cloud-object-storage-<random 2 characters>`,
  * Click `Confirm`,

* Click `Refresh`,
  * Make sure an Object Storage is now selected,
  * Click `Create`,

### 2. Create a Project Access token

To load the data into a notebook you need an Access Token.

- Go the Settings tab at the top of the Project and scroll down to `Access tokens`.
- Click `New token`
- Give the new token a name, e.g. `<username>-geopandas-token`, and select `Editor` and click `Create`

   ![Access Token](images/token.png)

### 3. Create a custom Python environment

As geopandas is not installed in the default Python environments you need to create a customized environment. This uses `conda create`. But as the environment is running in the Cloud there are a few steps to go through:

- Go to the environments tab at the top of your project
- Click on `new environment definition`

   ![New Environment](images/new_env.png)

- Give your new environment a name, e.g. `Custom Python conda - environment`,
- Keep the default, select the free hardware configuration `Free - 1 vCPU and 4 GB RAM` and click `Create`

   ![Customize Link](images/customize.png)

- In the next screen you can customize the new environment. Scroll down and click on the `Create` link under Customization

   ![Customize Environment](images/customize_env.png)

- A textfield appears that you can edit. Delete all text and copy and paste the below into the textfield:

   ```# Please add conda channels here
   channels:
   - defaults
   - conda-forge

   # Please add conda packages here
   dependencies:
   - geopandas
   - geoplot
   - pysal
   - folium

   # Please add pip packages here
   # To add pip packages, please comment out the next line
   #- pip:
   ```

- Click `Apply`

   ![Apply Environment](images/customize_env2.png)

- Now you can use this new environment to run notebooks

## 4. Load and run a notebook

- Go back to your project dashboard via the breadcrumb navigation,
- Add a new notebook. Click `Add to project` and choose `Notebook`:

   ![Add Notebook](images/newnotebook.png)

- Choose new notebook `From URL`.
- Give your notebook a name, e.g. `<username>-geopandas-notebook`,
- Copy the URL `https://github.com/jrtorres/geopandas-workshop/blob/master/notebooks/geopandas-workshop.ipynb`

   ![Notebook](images/notebookfromurl.png)

- Select the custom runtime enviroment that you created in step 3 and click `Create Notebook`.

-  The notebook will load, use the instructions in the notebook by running through the cells.

repository: remkohdev/geopandas-workshop

repo_name: remkohdev/geopandas-workshop


text:
Westminster Hubble
==================

A site for connecting constituents with their MPs. Ran at http://westminsterhubble.com from 2010-2013. Now defunct due to lack of use, and open sourced.

Development
-----------

Westminster Hubble was developed and launched privately, but a short series of blog posts note its release, describe how it works behind the scenes, and sadly a few years later document its demise.

1. [Announching: Westminster Hubble](https://ianrenton.com/blog/announcing-westminster-hubble/)
2. [The Technology of Westminster Hubble](https://ianrenton.com/blog/the-technology-of-westminster-hubble/)
3. [The End of Westminster Hubble](https://ianrenton.com/blog/the-end-of-westminster-hubble/)

Install on Heroku
-----------------

```
git clone https://github.com/ianrenton/westminsterhubble.git
cd westminsterhubble
cp sample.env .env
vi .env
heroku apps:create mywestminsterhubbleapp
heroku config:push
git commit -a -m "If anything has changed..."
git push heroku master
```

repository: ianrenton/westminsterhubble

repo_name: ianrenton/westminsterhubble


text:
---
name: Feature request
about: Suggest a new Feature for Mihari
title: "[Feature Request]"
labels: enhancement
assignees: ''

---
<!--

1. Make sure your requested feature makes sense for Mihari.

2. If you want to suggest a new integration of a service, please provide detailed information of it. (e.g. API docs)

-->

repository: ninoseki/mihari

repo_name: ninoseki/mihari


text:
---
layout: post
title: C. magister MiSeq data processing
---

I am helping to analyze some initial MBDSeq data from a Dungeness crab OA experiment, run by NOAA (Krista Nichols' group, with Mac) on the MiSeq to do a quick QC before sending the libraries off for full sequencing.

My task:
Run the MiSeq data through a trimming/mapping and alignment pipeline so we can get an idea of mapping efficiency and bisulfite conversion rate (i.e. CHG methylation from Bismark). The pipeline is based on the one developed by the MethCompare group (check out their repo), and which I tested for the WGBS data. See my WGBS pipeline in this Jupyter Notebook Notebook-01_Exploring-WGBS-data.ipynb.

### Check out my Jupyter Notebook entry for more details!: [MBD-01 Processing QC MiSeq data.ipynb](https://nbviewer.jupyter.org/github/laurahspencer/C.magister_methyl-oa/blob/master/notebooks/MBD-01%20Processing%20QC%20MiSeq%20data.ipynb)

Here's the Bismark summary report for the MiSeq data (NOTE: 6 of the samples are not here, since their data files were corrupted during transfer from NOAA). Click on the image to view in HTML format:

[![Bismark Summary Report](https://user-images.githubusercontent.com/17264765/102286490-48885e80-3eed-11eb-8a16-90655e61e051.png)](https://nbviewer.jupyter.org/github/laurahspencer/C.magister_methyl-oa/blob/master/qc-processing/MiSeq-QC/bismark/bismark_summary_report.html)

### Questions for Science Hour:

I could not get Jupyter Notebook to work on Mox despite following instructions on the Mox wiki.  I emailed the Mox folks, but haven't heard back. I instead just summarized my steps in the above Jupyter Notebook after running things on Mox.

I encountered a path/directory issue running Bismark on Mox.  I had to set my working directory to the folder which housed my trimmed reads (rather than specifying the read location).  According to the scripts written by others, for example [the one from the MethCompare group](https://github.com/hputnam/Meth_Compare/blob/master/code/00.02-C1-alignment.sh), this isn't necessary. What gives?

repository: laurahspencer/LabNotebook

gha_language: CSS

repo_name: laurahspencer/LabNotebook


text:
![image](https://user-images.githubusercontent.com/52920074/67153499-95a47c80-f2b8-11e9-92a9-02e1c50d9153.png)

## Overview

The objective was to create a train schedule application that incorporates Firebase to host arrival and departure data. My app retrieves and manipulates the data with Moment.js. This website provides up-to-date information about various trains, namely their arrival times and how many minutes remain until they arrive at their station.

## Requirements

### App must suit these basic specs:

When adding trains, administrators should be able to submit the following:

- Train Name
- Destination
- First Train Time -- in military time
- Frequency -- in minutes
- Calculate when the next train will arrive; relative to the current time.
- Users from many different machines must be able to view same train times.

## Firebase Configuration

```
 // Your web app's Firebase configuration
    var firebaseConfig = {
      apiKey: "AIzaSyA4171ciP79ckLBPoSd9_isrRm7YooNo1s",
      authDomain: "project-1-f9d74.firebaseapp.com",
      databaseURL: "https://project-1-f9d74.firebaseio.com",
      projectId: "project-1-f9d74",
      storageBucket: "project-1-f9d74.appspot.com",
      messagingSenderId: "232793427079",
      appId: "1:232793427079:web:ead826e9dbdd62a473fc22"
    };
    // Initialize Firebase
    firebase.initializeApp(firebaseConfig);
```

### Rules for Real-time-database

```
{
  /* Visit https://firebase.google.com/docs/database/security to learn more about security rules. */
  "rules": {
    ".read": true,
    ".write": true
  }
}
```

## Added Functionality

Form Validation for correct time input

## Link

[Train-Scheduler](https://keerthi-mani.github.io/Train-Scheduler/)

## Screenshots

![image](https://user-images.githubusercontent.com/52920074/67153509-c5ec1b00-f2b8-11e9-8c2e-e53bdb62039c.png)

![image](https://user-images.githubusercontent.com/52920074/67153537-1bc0c300-f2b9-11e9-8140-999467f70e20.png)

## Feedback and issues:

I really appreciate your feedback.

Additionally, if you find any issue when running the app or any other other matter, please feel free to open an issue in this Github repo.

## Author

Keerthi - 2019

## License

This project is licensed under the MIT License - see the LICENSE.md file for details

repository: Keerthi-Mani/Train-Scheduler

repo_name: Keerthi-Mani/Train-Scheduler


text:
# py_webScraper
A simple web scraper using beautifulsoup and requests

## File Descriptions:
simmpleWebScraper.py : It is a simple web scraper built using requests and beautifulsoup to get data from any website.

googleImages.py : Contains a google images web scraper to obtain images from Google using ChromeWebDriver, Selenium and BeutifulSoup

googleImagesWithRequests.py : This webscraper for google images uses the requests library and beautifulsoup.
sampleGoogleImages.html : This is the page which is obtained when using the requests library.

As it can be seen that using the WebDriver more images can be obtained because it enables the use of Javascript while using the requests library we get pure HTML and CSS.


text:
# Dark Mode

_Livres_ came with 2 theme, light theme and dark theme.

The selection of theme is automatic, based on your browser [preferred color scheme](https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-color-scheme), which is normally set accordling to [your OS choice](https://web.dev/prefers-color-scheme/#activating-dark-mode-in-the-operating-system).

The default theme is teh light one, which mean, this your browser don't support color scheme, it will the used theme.

## Light theme

![library](images/library-list-light.png)

![library](images/library-grid-light.png)

![library](images/view-light.png)

![library](images/search-light.png)

![library](images/add-light.png)

## Dark theme

![library](images/library-list-dark.png)

![library](images/library-grid-dark.png)

![library](images/view-dark.png)

![library](images/search-dark.png)

![library](images/add-dark.png)

repository: MacFJA/livres

gha_language: PHP

repo_name: MacFJA/livres


text:
# igorw/compose

Function composition.

Allows you to stitch functions together to form a pipeline. This can be useful
if you have to transform data in many steps and you want to describe those
steps on a high level.

## compose

Generally, function composition means taking two functions `f` and `g`, and
producing a new function `z`, which applies `f` to the result of `g`.

    z = compose(f, g)
    ; z(x) => f(g(x))

This library provides a `compose` function that does just this.

    $z = igorw\compose($f, $g);
    var_dump($z($x));

It supports an arbitrary number of functions to be composed via varargs.

    $z = igorw\compose($f, $g, $h, $i);

The innermost function (the last one in the list) can take an arbitrary number
of arguments, whereas the others may only take a single argument.

    $z = igorw\compose($f, $g);
    $z('a', 'b', 'c');
    // => $f($g('a', 'b', 'c'))

## pipeline

`pipeline` is the same as `compose`, but the arguments are reversed. This is
more easy to read in some cases, because you can list the functions in the
order they will be called.

It is quite similar to a unix pipe in that regard.

## Examples

    function transform_data($data) {
        return [
            'name' => $data['firstname'].' '.$data['lastname'],
        ];
    }

    $transformJson = igorw\pipeline(
        function ($json) { return json_decode($json, true); },
        'transform_data',
        'json_encode'
    );

    $json = <<<EOF
    {"firstname": "Igor", "lastname": "Wiedler"}
    {"firstname": "Beau", "lastname": "Simensen"}
    EOF;

    $list = explode("\n", $json);
    $newList = array_map($transformJson, $list);
    $newJson = implode("\n", $newList);

    // =>
    // {"name": "Igor Wiedler"}
    // {"name": "Beau Simensen"}

repository: gobb/compose

repo_name: gobb/compose


text:
# message-serialization
Python module for serialization and deserialization of structured data.
The data is described in a simple class format, similar to dataclasses.

@message
class User:
  name: 'utf-8'
  age: '<B'