text:
# PHP Simple HTML DOM Parser

[![LICENSE](https://img.shields.io/github/license/simplehtmldom/simplehtmldom?logo=github&style=for-the-badge)](https://github.com/simplehtmldom/simplehtmldom/blob/master/LICENSE)
[![RELEASE](https://img.shields.io/github/v/tag/simplehtmldom/simplehtmldom?label=release&logo=sourceforge&style=for-the-badge)](https://sourceforge.com/projects/simplehtmldom/files/simplehtmldom/)
[![BASIC TESTS](https://img.shields.io/github/workflow/status/simplehtmldom/simplehtmldom/Basic%20Tests?label=Basic%20Tests&logo=github&style=for-the-badge)](https://github.com/simplehtmldom/simplehtmldom/actions/workflows/basic_tests.yml)
[![PACKAGIST](https://img.shields.io/packagist/v/simplehtmldom/simplehtmldom?logo=composer&style=for-the-badge)](https://packagist.org/packages/simplehtmldom/simplehtmldom)

simplehtmldom is a fast and reliable HTML DOM parser for PHP.

## Key features

* Purely PHP-based DOM parser (no XML extensions required).
* Works with well-formed and broken HTML documents.
* Loads webpages, local files and document strings.
* Supports CSS selectors.

## Requirements

simplehtmldom requires **PHP 5.6 or higher** with [ext-iconv](https://www.php.net/manual/en/book.iconv.php) enabled. Following extensions enable additional features of the parser:

* [ext-mbstring](https://secure.php.net/manual/en/book.mbstring.php) (recommended) \
Enables better detection for multi-byte documents.
* [ext-curl](https://secure.php.net/manual/en/book.curl.php) \
Enables cURL support for the class `HtmlWeb`.
* [ext-openssl](https://secure.php.net/manual/en/book.openssl.php) (recommended when using cURL) \
Enables SSL support for cURL.

## Installation

**Manually**:

Download the latest release from [SourceForge](https://sourceforge.net/projects/simplehtmldom/files/latest) and extract the files in the vendor folder of your project.

**Composer**:

```sh
composer require simplehtmldom/simplehtmldom
```

**Git**:

```
git clone git://git.code.sf.net/p/simplehtmldom/repository simplehtmldom
```

_Note_: The [GitHub repository](https://github.com/simplehtmldom/simplehtmldom) serves as a mirror for the SourceForge project. We currently accept pull requests and issues only via SourceForge.

## Usage

This example illustrates how to return the page title:

Manually

```
<?php
include_once 'HtmlWeb.php';
use simplehtmldom\HtmlWeb;

$client = new HtmlWeb();
$html = $client->load('https://www.google.com/search?q=simplehtmldom');

// Returns the page title
echo $html->find('title', 0)->plaintext . PHP_EOL;
```

Using composer

```
<?php
include_once 'vendor/autoload.php';
use simplehtmldom\HtmlWeb;

$client = new HtmlWeb();
$html = $client->load('https://www.google.com/search?q=simplehtmldom');

// Returns the page title
echo $html->find('title', 0)->plaintext . PHP_EOL;
```

Find more examples in the installation folder under `examples`.

## Documentation

The documentation for this library is hosted at [https://simplehtmldom.sourceforge.io/docs/](https://simplehtmldom.sourceforge.io/docs/)

## Getting involved

There are various ways for you to get involved with simplehtmldom. Here are a few:

* Share this project with your friends (Twitter, Facebook, ..._you name it_...).
* Report [bugs](https://sourceforge.net/p/simplehtmldom/bugs/) (SourceForge).
* Request [features](https://sourceforge.net/p/simplehtmldom/feature-requests/) (SourceForge).
* Discuss existing bugs, features and ideas.

If you want to contribute code to the project, please open a [feature request](https://sourceforge.net/p/simplehtmldom/feature-requests/) and include your patch with the message.

## Authors

 * [S.C. Chen](https://sourceforge.net/u/me578022/)
 * [John Schlick](https://sourceforge.net/u/john_schlick/)
 * [logmanoriginal](https://sourceforge.net/u/logmanoriginal/)
 * Rus Carroll
 * Yousuke Kumakura
 * Vadim Voituk

## License

The source code for simplehtmldom is licensed under the MIT license. For further information read the LICENSE file in the root directory (should be located next to this README file).

## Technical notes

simplehtmldom is a purely PHP-based DOM parser that doesn't rely on external libraries like [libxml](https://www.php.net/manual/en/book.libxml.php), [SimpleXML](https://www.php.net/manual/en/book.simplexml.php) or [PHP DOM](https://www.php.net/manual/en/book.dom.php). Doing so provides better control over the parsing algorithm and a much simpler API that even novice users can learn to use in a short amount of time.

repository: simplehtmldom/simplehtmldom

gha_language: HTML

repo_name: simplehtmldom/simplehtmldom


text:
# Microservices Setup \[beta\]

{% hint style="info" %}
This guide is currently only valid for a special distribution of the Rocket.Chat.

The feature will be release for **General Availability** on the **Enterprise Edition v4.0**
{% endhint %}

### Pre-requisites

* NATS
  * Please refer to [NATS Docker installation](https://docs.nats.io/nats-server/nats_docker) on how to deploy NATS
* MongoDB
  * Storage Engine needs to be [WiredTiger](https://docs.mongodb.com/manual/core/wiredtiger/):
    * [Change Standalone to WiredTiger](https://docs.mongodb.com/manual/tutorial/change-standalone-wiredtiger/)
* Rocket.Chat
  * The setting **Use REST instead of websocket for Meteor calls** under _Admin > General > REST API_, _must_ be **enabled**.

### Micro services

Rocket.Chat micro services are composed by a few Docker containers:

![](../.gitbook/assets/image%20%283%29.png)

#### Accounts

{% hint style="info" %}
Can be scaled to multiple containers
{% endhint %}

Responsible for user authentications

```
docker run \
--name accounts-service \
-e MONGO_URL=mongodb://mongo/rocketchat?replicaSet=rs01 \
-e TRANSPORTER=nats://nats:4222 \
registry.rocket.chat/microservices_accounts-service:latest
```

#### Authorization

{% hint style="info" %}
Can be scaled to multiple containers
{% endhint %}

Responsible for validate access to features

```
docker run \
--name authorization-service \
-e MONGO_URL=mongodb://mongo/rocketchat?replicaSet=rs01 \
-e TRANSPORTER=nats://nats:4222 \
registry.rocket.chat/microservices_authorization-service:latest
```

#### DDP Streamer

{% hint style="info" %}
Can be scaled to multiple containers
{% endhint %}

Web socket interface between server and clients

```
docker run \
--name ddp-streamer \
-e MONGO_URL=mongodb://mongo/rocketchat?replicaSet=rs01 \
-e TRANSPORTER=nats://nats:4222 \
registry.rocket.chat/microservices_ddp-streamer:latest
```

#### MongoDB Stream Hub

Receives real time data from MongoDB and emits that data to the system.

```
docker run \
--name mongodb-stream-hub \
-e MONGO_URL=mongodb://mongo/rocketchat?replicaSet=rs01 \
-e TRANSPORTER=nats://nats:4222 \
registry.rocket.chat/microservices_mongodb-stream-hub:latest
```

#### Presence

{% hint style="info" %}
Can be scaled to multiple containers
{% endhint %}

Controls and update users presence status.

```
docker run \
--name presence-service \
-e MONGO_URL=mongodb://mongo/rocketchat?replicaSet=rs01 \
-e TRANSPORTER=nats://nats:4222 \
registry.rocket.chat/microservices_presence-service:latest
```

### Reverse proxy

Once all services are up and running the web socket connections should be targeted to "ddp-streamer" containers, the configuration depends on the reverse proxy you have set up, but you need to change the following routes:

* `/sockjs`
* `/websocket`

If using Kubernetes, an Ingress like the following can be used:

```text
apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  name: ddp-streamer
spec:
  rules:
  - host: your-hostname.rocket.chat
    http:
      paths:
      - backend:
          serviceName: ddp-streamer
          servicePort: 3000
        path: /(sockjs|websocket)
```

license: MIT

repository: Rodriq/docs

branch_name: refs/heads/master

extension: md

gha_license_id: MIT

license_type: permissive

repo_name: Rodriq/docs


text:
# create-3h-node

> A node lib initializer.

## Introduction

This is a CLI tool that helps you quickly initialize a development environment for your awesome node library.

## Usage

```txt
$ create-3h-node --help
A front-end lib initializer.

Usage:
  create-3h-node [options]

Options:
  --name, -n <pkg>              The name of the package
  --author, -a <name>           The author of the package
  --desc, -d <description>      The description of the package
  --keywords, -k <words...>     The keywords of the package
  --repo, -r <repository>       The repository of the package
  --no-install                  Do not install dependencies instantly
  --help, -h                    Show help info

```

## Example

```bash
npm init 3h-node -n my-awesome-lib -a Peter -d "This is my awesome lib"
# or
npx create-3h-node -n my-awesome-lib -a Peter -d "This is my awesome lib"
```

## Template Structure

```txt
your-awesome-lib/
+-- src/
| `-- index.ts
+-- test/
| `-- index.js
+-- .gitignore
+-- CHANGELOG.md
+-- LICENSE
+-- README.md
`-- tsconfig.json
```

## Workflow

Generally, you

1. Write your source code in the `src` folder in TypeScript
2. Build your lib by executing `npm run build`
3. Write test code in `test/index.js`
4. Execute `test/index.js` to test your lib
5. ...

## Built-in Scripts

| name    | description         |
|:--------|:--------------------|
| `build` | build your code     |
| `docs`  | build API reference |

Specifically, after building your code by executing `npm run build`, compiled JavaScript files are placed in the `js` folder. Additionally, you can execute `npm run docs` to build the API reference of your lib using package [`dts2md`](https://www.npmjs.com/package/dts2md). By default, documentation files are placed in the `docs` folder.


text:
# Passport-Real-Debrid

[Passport](http://passportjs.org/) strategy for authenticating with [Real-Debrid](https://real-debrid.com/)
using the OAuth 2.0 API.

This module lets you authenticate using Real-Debrid in your Node.js applications.
By plugging into Passport, Real-Debrid authentication can be easily and
unobtrusively integrated into any application or framework that supports
[Connect](http://www.senchalabs.org/connect/)-style middleware, including
[Express](http://expressjs.com/).

## Install

    $ npm install passport-real-debrid

## Usage

#### Configure Strategy

The Real-Debrid authentication strategy authenticates users using a Real-Debrid account
and OAuth 2.0 tokens.  The strategy requires a `verify` callback, which accepts
these credentials and calls `done` providing a user, as well as `options`
specifying a client ID, client secret, and callback URL.

    passport.use(new RealDebridStrategy({
        clientID: REAL_DEBRID_CLIENT_ID,
        clientSecret: REAL_DEBRID_CLIENT_SECRET,
        callbackURL: "https://<IP_ADDRESS>:3000/auth/real-debrid/callback"
      },
      function(accessToken, refreshToken, params, profile, done) {
        User.findOrCreate({ realDebridId: profile.id }, function (err, user) {
          return done(err, user);
        });
      }
    ));

#### Authenticate Requests

Use `passport.authenticate()`, specifying the `'real-debrid'` strategy, to
authenticate requests.

For example, as route middleware in an [Express](http://expressjs.com/)
application:

    app.get('/auth/real-debrid',
      passport.authenticate('real-debrid'));

    app.get('/auth/real-debrid/callback',
      passport.authenticate('real-debrid', { failureRedirect: '/login' }),
      function(req, res) {
        // Successful authentication, redirect home.
        res.redirect('/');
      });

## Credits

  - [Paul Bottein](http://github.com/piitaya)

## License

[The MIT License](https://github.com/piitaya/passport-real-debrid/blob/master/LICENSE)

Copyright (c) 2016 Paul Bottein

repository: piitaya/passport-real-debrid

repo_name: piitaya/passport-real-debrid


text:
# React Employee Directory [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
This is progressive web application built for my fullstack coding bootcamp. This application is built off of React, and is used to display my most recent code projects, my resume, as well as any other job-search information to display to employers!

## Table of Contents

[Assignment Acceptance Criteria](#assignment-acceptance-criteria)

[Installing/Dependencies](#installingdependencies)

[Usage Information](#usage-information)

[Walkthrough](#walkthrough)

[Contributing to this project](#contributing-to-this-project)

[Questions?](#questions)

[License](#license)

## Assignment Acceptance Criteria
### Acceptance Criteria

```Your updated site should still have all of the content it previously had:

    Your name

    Links to your GitHub profile & LinkedIn page as well as your email address and phone number

    A link to a PDF of your resume with updated projects

    A list of projects. For each project, make sure you have the following:

    Project title

    Link to the deployed version

    Link to the GitHub repository

    GIF or screenshot of the deployed application

```

## Installing/Dependencies
```npm i axios```
```npm i gh-pages```
```npm i react```
```npm i react-dom```
```npm i react-dom-router```
```npm i react-scripts```
```npm i web-vitals```

## Usage Information
Clone this project, install the required dependencies, and run 'npm start' in your terminal.

Or, alternatively, visit the deployed version of the finished project on Heroku [here]( https://github.com/thelbaumann/react-portfolio).

## Walkthrough

The landing page displays a short summary of my work history and links to related files and socials. The two navigational links can be used to navigate to see my most recent coding projects as well as more contact information. The landing page can be navigated back to at any time by clicking the main heading in the header (name + photo at the top).

![Gif Walkthrough of Application](https://media.giphy.com/media/q4cc7I0PSCJ1YKiIAm/giphy.gif).

## Contributing to this project
Pull requests are welcome! Find my contact information below to reach out about collaborating with me.

## Questions?
[Laura Baumann](https://github.com/thelbaumann) -- You can reach me anytime for questions or collaboration at<EMAIL_ADDRESS>## License
This project is licensed under [MIT](LICENSE) - 2020 Laura Baumann

repository: thelbaumann/react-portfolio

branch_name: refs/heads/main

repo_name: thelbaumann/react-portfolio


text:
# EFWorkshop

Welcome to Entity Framework Core Workshop.

## Requirements

For doing the exercises I recommend to you to have Visual Studio (min version 2017), netcore 3 installed and SQL Server Management Studio.
Here I left to you

- [Sql Management Studio](https://docs.microsoft.com/es-es/sql/ssms/download-sql-server-management-studio-ssms?view=sql-server-ver15)
- [NetCore 3.1](https://dotnet.microsoft.com/download/dotnet/3.1)
- [Visual Studio 2019](https://visualstudio.microsoft.com/es/vs/)

## How play with exercises

All the exercises have two folders, one named ```start``` with the solution with the exercise unresolved, if you need some help or you want to see how is the solution you will found this solution on ```end``` folder

## Exercises Order

- [Basic Scaffolding](/exercises/EntitiesScaffolding/Exercise.md)
- [DbMappings](/exercises/DbMappings/Exercise.md)
- [Relationships](/exercises/RelationShips/Exercise.md)
- [Working with aspnet core](/exercises/WorkingOnAspNetCore/Exercise.md)
- [Extending aspnet core](/exercises/PatternsAndPractices/Exercise.md)

repository: jmanuelcorral/EFWorkshop

repo_name: jmanuelcorral/EFWorkshop


text:
---
layout: post
title: 'Links 2007-02-25'
---
[Universal Data Type Checker](http://www.madskristensen.dk/blog/PermaLink,guid,f039bd8a-437e-4101-b607-fdba975d5560.aspx)
Here's a neat little C# function for checking if one can convert a string value to a specific type.

Here are some examples:

    CanConvert("12", typeof(int)); // true
    CanConvert("f637a876-9d58-4229-9559-a5e42a95fdac ", typeof(Guid)); // true
    CanConvert("Backspace", typeof(System.ConsoleKey)); // true
    CanConvert("10px", typeof(System.Web.UI.WebControls.Unit)); // true
    CanConvert("red", typeof(System.Drawing.Color)); // true

[Windows Vista’s three killer features](http://blogs.zdnet.com/Bott/?p=190)
I've heard many people trash talk Vista. I heard the same thing when XP debuted. Ed Bott actually has spent time with the Vista and offers up what I would call a "fair" assessment of the Microsoft's latest offering.

[C# Keyboard Shortcut Posters](http://blog.csharp-online.net/?p=90)
Here is a really nice, colorful poster of the standard C# keyboard shortcuts. You'll need a printer that can print on 18" paper to get the full resolution of this one. It's Ok on legal size paper as well.

[Inspire Yourself: 50 Remarkable Favicons](http://www.smashingmagazine.com/2007/01/31/inspire-yourself-50-remarkable-favicons/)
The good folks at Smashing Magazine of an excellent collection of Favicons free for the taking. ![](/cdn/images/blog/WindowsLiveWriter/Links20070225_E202/3a%5B4%5D.gif)

[SILK ICONS](http://www.famfamfam.com/lab/icons/silk/)
More lovely and free icons for your Web site.

[MeasureIt - Firefox ruler extension](http://www.kevinfreitas.net/extensions/measureit/)
This is a really nice measuring tool for Firefox browsers. Draw a ruler across any Web page to check the width, height, or alignment of page elements in pixels.

[About protocol links - MozillaZine Knowledge Base](http://kb.mozillazine.org/About_protocol_links)
This is a listing of all the about protocol links in Firefox. There are a few special URLs, which begin with **about:**, that you can type into the Location Bar.

[MS AJAX 1.0 is here](http://west-wind.com/WebLog/posts/10494.aspx)
Rick Strahl's blog is one of the best overviews of MS AJAX 1.0 I've read to date.

[Context Help Made Easy](http://www.codeproject.com/csharp/ContextHelpMadeEasy.asp)
This article introduces a way to instrument your code that enables help authors to associate help topics with the application's visual contexts at any time - even post-compilation – and to do so using the application's user interface without the involvement of the developer. There is no need for the help author to manually edit any files or have knowledge of any internals.

[X-Hawk: The Revolutionary, Modular, VTOL Aircraft](/cdn/images/blog/WindowsLiveWriter/Links20070225_E202/clrplatformsmall%5B3%5D.jpg)
X-Hawk is a ‘rotorless’ Vertical-Take-Off and Landing (VTOL) aircraft. To be more precise, it is an aircraft that has the VTOL capability of a helicopter, but without the exposed rotors that make it dangerous or impossible for helicopters to maneuver in complex urban and natural environments.


text:
# Autocomplete

This project is a simulation of the **Google auto-complete** feature. The program suggests up to 4 words based on the letters type(not case sensitve), except that the resuts are not ranked but naturally ordered.

## Getting Started
You can run the program with the sbt or in your favorite IDE. The main class is `com.satybald.Main`.

The program expects a user to enter his letters from StdIn and then press Enter.

![AutoComplete](auto-complete.png)

The project runs until users submit non empty line.

## Optional questions
> What would you change if the list of keywords was large (several millions)?

I would compress Trie, and merge the common branches which should reduce memory foot print and gain performance speedup.

> What would you change if the requirements were to match any portion of the keywords?

I would use [Aho–Corasick algorithm](https://en.wikipedia.org/wiki/Aho%E2%80%93Corasick_algorithm) which is Trie + regular automata to build a tree and do a partial match on the input keywords.

## Installing
The project has minimalistic dependencies. To run the program it requires installed sbt and scala-test.

After installation the program can be run with:
```
sbt runMain com.satybald.Main
```

## Running the tests
```
sbt test
```

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

repository: satybald/auto-complete

repo_name: satybald/auto-complete


text:
# ZPages Example

In this example, we demonstrate how to use zpages to analysis spans.

Run the following command to start the server on `localhost:3000`
```base
cargo run --example zpages
```

1. Then try to access `localhost:3000/running` endpoint. Each request sent to this endpoint will generate a trace whose latency is between 1 ms to 5 s. The latency for each trace will be printed in cmd.

2. Check `localhost:3000/api/tracez/aggregations` to see the count of running spans, error spans and spans within different latency.

repository: open-telemetry/opentelemetry-rust

gha_language: Rust

repo_name: open-telemetry/opentelemetry-rust


text:
# HfvExplorerSharp

This is a work in progress project to build a replacement for [HfvExplorer](https://www.emaculation.com/doku.php/hfvexplorer).

## Why?
The source code the original HFVExplorer has been lost to time. There's some features I'd like added (auto-type mapping, etc).

### Initial focus:
 - [ ] Simple cross-platform UI to open HFV files and view files via [DiscUtils](https://github.com/DiscUtils/DiscUtils).
 - [ ] Add HFS+ Write support to DiscUtils
 - [ ] Add HFV container support to DiscUtils

### Long Term Plans:
 - [ ] BinHex support
 - [ ] StuffIt Expansion (eg look at how the Unarchiver code works and see if I can reimplement it in C#)
 - [ ] Extraction with Resource forks
 - [ ] Creator/Type mapping
 - [ ] Direct Drive access
 - [ ] Support other formats supported by DiscUtils

## Resources
Many resources will be called on for this project to see how things work
 - [HFS Utilities](https://www.mars.org/home/rob/proj/hfs/)
 - [HFSExplorer](http://www.catacombae.org/hfsexplorer/) Is a mature tool available today with more features than I plan to add.
 - [DiscUtils](https://github.com/DiscUtils/DiscUtils) is a C# library for reading and writing various containers and filesystems.

## License
TBA - will be dicated by libraries, code used. Happy for MIT, BSD or similar.

repository: pgodwin/HfvExplorerSharp

repo_name: pgodwin/HfvExplorerSharp


text:
# About

This project is used to develop applications for the STM32 - ST's ARM Cortex-Mx MCUs. It uses cmake and GCC, along with newlib (libc), STM32CubeMX or ChibiOS.

## Requirements

* cmake >= 3.0
* GCC toolchain with newlib (optional).
* STM32CubeMX package for STM32F0, STM32F1, STM32F2, STM32F3, STM32F4, STM32F7, STM32H7, STM32L0, STM32L1, STM32L4 families.

## Project contains

* CMake common toolchain file, that configures cmake to use the arm toolchain.
* CMake toolchain file that can generate a tunable linker script
* CMake STM32 family-specific toolchain file, that configures family-specific parameters.
* CMake modules to find and configure CMSIS and STM32HAL components.
* CMake modules to find and configure ChibiOS components.
* CMake project template.

## Examples

* `stm32-blinky` - blink LED using timers and PWM.
* `stm32-newlib` - show date using uart and libc functions from newlib.
* `stm32-chibios` - blink led using ChibiOS/NIL.

# Usage

First of all you need to configure toolchain and libraries, you can do this by editing `gcc_stm32.cmake` or, preferably, by passing it through the command line.

## Configuration

* `TOOLCHAIN_PREFIX` - where toolchain is located, **default**: `/usr`
* `TARGET_TRIPLET` - toolchain target triplet, **default**: `arm-none-eabi`
* `STM32_CHIP` - STM32 device code, e.g. `STM32F407VG` or `STM32F103VG`
* `STM32_FAMILY` - STM32 family (F0, F1, F4, etc.) currently, F0, F1, F2, F4, F7, H7, L0, L1 and L4 families are supported. **Note:** If `STM32_CHIP` variable is set, `STM32_FAMILY` is optional.
* `STM32Cube_DIR` - path to STM32CubeMX directory **default**: `/opt/STM32Cube_FW_F0_V1.4.0 /opt/STM32Cube_FW_F1_V1.1.0 /opt/STM32Cube_FW_F2_V1.1.0 /opt/STM32Cube_FW_F4_V1.6.0`

To use the toolchain, you'll need to copy contents of the `cmake` folder into cmake's modules path, or use the `CMAKE_MODULE_PATH` variable.

## Common usage

    cmake -DSTM32_CHIP=<chip> -DCMAKE_TOOLCHAIN_FILE=<path_to_gcc_stm32.cmake> -DCMAKE_BUILD_TYPE=Debug <path_to_source_dir>

Where `<chip>` is the STM32 chip name (e.g. `STM32F100C8`, `STM32F407IG`).

This command will generate Makefile for project. For a `Release` build, change `CMAKE_BUILD_TYPE`.

The script will try to detect chip parameters automatically from the chip name (type, flash/ram size), or, you can set these directly with these variables:

* `STM32_CHIP_TYPE` - family-dependent chip type. Global variable `STM32_CHIP_TYPES` contains list of valid types for current family (e.g `207xG`)
* `STM32_FLASH_SIZE` - chip flash size (e.g. 64K)
* `STM32_RAM_SIZE` - chip RAM size (e.g. 4K)

### Usage with Eclipse CDT:

    cmake -DSTM32_CHIP=<chip> -DCMAKE_TOOLCHAIN_FILE=<path_to_gcc_stm32.cmake> -DCMAKE_BUILD_TYPE=Debug -G "Eclipse CDT4 - Unix Makefiles" <path_to_source_dir>

## Building

* To build elf file: `make`
* To build .hex: `make <project name>.hex`
* To build .bin: `make <project name>.bin`

## Linker script & variables

You can use cmake variables below to tune the generated linker. To specify a custom linker script, set `STM32_LINKER_SCRIPT` (you can still use these variables in your custom script).

* `STM32_FLASH_ORIGIN` - Start address of flash (**default**: 0x08000000)
* `STM32_RAM_ORIGIN` - Start address of RAM (**default**: 0x20000000)
* `STM32_FLASH_SIZE` - Flash size (**default**: from chip name)
* `STM32_RAM_SIZE` - RAM size (**default**: from chip name)
* `STM32_MIN_STACK_SIZE` - Minimum stack size for error detection at link-time (**default**: 512 bytes)
* `STM32_MIN_HEAP_SIZE` - Minimum heap size for error detection at link-time (**default**: 0 bytes)
* `STM32_CCRAM_ORIGIN` - Start address of Core-Coupled RAM (**default**: 0x10000000)
* `STM32_CCRAM_SIZE` - Core-Coupled RAM size (**default**: 64 KiB)

## Useful cmake macros

* `STM32_GET_CHIP_TYPE(CHIP CHIP_TYPE)` - gets chip type from chip name.
* `STM32_GET_CHIP_PARAMETERS(CHIP FLASH_SIZE RAM_SIZE CCRAM_SIZE)` - gets chip ram/flash size from chip name.
* `STM32_SET_FLASH_PARAMS(TARGET ...)` - sets chip flash/ram parameters for target.
* `STM32_SET_CHIP_DEFINITIONS(TARGET CHIP_TYPE)` - sets chip family and type-specific compiler flags for target.
* `STM32_SET_TARGET_PROPERTIES(TARGET)` - sets all needed parameters and compiler flags for target.
* `STM32_GENERATE_LIBRARIES(NAME SOURCES LIBRARIES)` - generates libraries for all chip types in family. Resulting libraries stored in LIBRARIES and have names in ${NAME}_${FAMILY}_${CHIP_TYPE} format.

# ChibiOS Support

This project also supports ChibiOS v3.x.x and ChibiOS v16.x.x (both nil and rt kernels).

CMake modules for ChibiOS can find specified ChibiOS components using the COMPONENTS directive.

See project `stm32-chibios` for example usage.

# FreeRTOS Support

FreeRTOS is also supported. To include it in your project you should set a variable named `FREERTOS_HEAP_IMPL` with
a proper number of FreeRTOS heap implementation. You can do this by invoking:

```
SET(FREERTOS_HEAP_IMPL 4)
```

before `FIND_PACKAGE` command.

gha_language: C


text:
---
layout: news
title: First BioExcel Webinar
date: 2016-04-17
excerpt: First BioExcel Webinar on integrative modelling using HADDOCK
tags: [HADDOCK, Utrecht University, Alexandre Bonvin, Docking]
image:
  feature:
---
The [BioExcel CoE](http://www.bioexcel.eu) is launching new series of educational webinars for computational biomolecular research. The series will cover broad topics related to the latest development of major software packages; their application to modelling and simulation; best practices for performance tuning and efficient usage on HPC and novel architectures; introductory tutorials for novel users and much more.

The webinars include an audience Q&A session during which attendees can ask questions and make suggestions. They are a great opportunity to interact with the main code developers.

Our first webinar in the series will be:

   * **Webinar:** *“Integrative modelling of biomolecular complexes with HADDOCK”*
   * **Presenter:** Alexandre Bonvin
   * **Date:** Friday,  Apr 29, 2016
   * **Time:** 16:00-17:00 CET (Central European Time)
   * **Registeration:** Free

Register online at [https://attendee.gotowebinar.com/register/7197777060128771](https://attendee.gotowebinar.com/register/7197777060128771). After registering, you will receive a confirmation email containing information about joining the webinar.

More information is available [here](http://bioexcel.eu/webinar-integrative-modelling-of-biomolecular-complexes-with-haddock/)


text:
# Open Problems in Single-Cell Analysis

![GitHub Workflow Status](https://img.shields.io/github/workflow/status/singlecellopenproblems/singlecellopenproblems/Run%20Tests/master?label=Github%20Actions)
![Coverage Status](https://img.shields.io/codecov/c/github/singlecellopenproblems/SingleCellOpenProblems/master)
[![Netlify Status](https://api.netlify.com/api/v1/badges/83b92388-53c7-4fef-9003-e14d94c6ac6f/deploy-status)](https://app.netlify.com/sites/openproblems/deploys)
[![Code Style: Black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
[![Style Guide: OpenStack](https://img.shields.io/badge/style%20guide-openstack-eb1a32.svg)](https://docs.openstack.org/hacking/latest/user/hacking.html#styleguide)
[![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)

Formalizing and benchmarking open problems in single-cell genomics.

[**Visit the Open Problems Website.**](https://openproblems.bio/)

For contributing guidelines, see [CONTRIBUTING.md](CONTRIBUTING.md).

## The team

**Core**:
* Scott Gigante (@scottgigante)
* Daniel Burkhardt (@dburkhardt)
* Malte Luecken (@LuckyMD)
* Angela Pisco (@aopisco)
* Olga Botvinnik (@olgabot)

**Task authors** (_alphabetically_):
* Mohammad Lotfallahi (@M0hammadL) - Label projection task
* Qian Qin (@qinqian) - Predicting gene expression from chromatin accessibility
* Michael Vinyard (@mvinyard) - Stress preservation in Dimensionality Reduction
* Florian Wagner (@flo-compbio) - Data denoising

**Supervision** (_alphabetically_):
* Smita Krishnaswamy, Yale
* Fabian Theis, Helmholtz Munich

**Chan Zuckerberg Initiative Support** (_alphabetically_):
* Jonah Cool
* Fiona Griffin


text:
---
toc: true
layout: post
categories: [releases]
comments: true
title: Kubeflow 1.0 - Cloud Native ML for Everyone
author: Thea Lamkin (Google), Jeremy Lewi (Google), Josh Bottum (Arrikto), Elvira Dzhuraeva (Cisco), David Aronchick (Microsoft), Amy Unruh (Google), Animesh Singh (IBM), and Ellis Bigelow (Google).
---

# Kubeflow 1.0: Cloud Native ML for Everyone

On behalf of the entire community, we are proud to announce Kubeflow 1.0, our first major release. Kubeflow was open sourced at Kubecon USA in December 2017, and during the last two years the Kubeflow Project has grown beyond our wildest expectations. There are now hundreds of contributors from over 30 [participating organizations](https://github.com/kubeflow/community/blob/master/member_organizations.yaml).

Kubeflow’s goal is to make it easy for machine learning (ML) engineers and data scientists to leverage cloud assets (public or on-premise) for ML workloads. You can use Kubeflow on any Kubernetes-conformant cluster.

With 1.0, we are graduating a core set of stable applications needed to develop, build, train, and deploy models on Kubernetes efficiently. (Read more in Kubeflow’s [versioning policies](https://www.kubeflow.org/docs/reference/version-policy/) and [application requirements](https://github.com/kubeflow/community/blob/master/guidelines/application_requirements.md) for graduation.)

Graduating applications include:

* Kubeflow’s UI, the [central dashboard](https://www.kubeflow.org/docs/components/central-dash/overview/)

* [Jupyter notebook controller](https://github.com/kubeflow/kubeflow/tree/master/components/notebook-controller) and [web app](https://www.kubeflow.org/docs/notebooks/why-use-jupyter-notebook/)

* [Tensorflow Operator](https://www.kubeflow.org/docs/components/training/tftraining/) (TFJob) and [PyTorch Operator](https://www.kubeflow.org/docs/components/training/pytorch/) for distributed training

* [kfctl](https://www.kubeflow.org/docs/other-guides/kustomize/) for deployment and upgrades

* [Profile controller](https://github.com/kubeflow/kubeflow/tree/master/components/profile-controller) and UI for multiuser management

*Hear more about Kubeflow’s mission and 1.0 release in [this](http://kubernetespodcast.com/episode/093-kubeflow-1.0/) interview with Kubeflow founder and core contributor Jeremy Lewi on the Kubernetes Podcast.*

## Develop, Build, Train, and Deploy with Kubeflow

![Kubeflow’s 1.0 applications that make up our develop, build, train, deploy critical user journey.](https://cdn-images-1.medium.com/max/3200/0*tBPpU3UqM_MeJ0-P)*Kubeflow’s 1.0 applications that make up our develop, build, train, deploy critical user journey.*

With Kubeflow 1.0, users can use Jupyter to develop models. They can then use Kubeflow tools like [fairing](https://www.kubeflow.org/docs/fairing/) (Kubeflow’s python SDK) to build containers and create Kubernetes resources to train their models. Once they have a model, they can use [KFServing](https://github.com/kubeflow/kfserving) to create and deploy a server for inference.

### Getting Started with ML on Kubernetes

Kubernetes is an amazing platform for leveraging infrastructure (whether on public cloud or on-premises), but deploying Kubernetes optimized for ML and integrated with your cloud is no easy task. With 1.0 we are providing a CLI and configuration files so you can deploy Kubeflow with one command:

    kfctl apply -f [kfctl_gcp_iap.v1.0.0.yaml](https://github.com/kubeflow/manifests/blob/master/kfdef/kfctl_gcp_iap.yaml)

    kfctl apply -f [kfctl_k8s_istio.v1.0.0.yaml](https://github.com/kubeflow/manifests/blob/master/kfdef/kfctl_gcp_iap.yaml)

    kfctl apply -f [kfctl_aws_cognito.v1.0.0.yaml](https://github.com/kubeflow/manifests/blob/master/kfdef/kfctl_gcp_iap.yaml)

    kfctl apply -f [kfctl_ibm.v1.0.0.yaml](https://github.com/kubeflow/manifests/blob/master/kfdef/kfctl_gcp_iap.yaml)

### Jupyter on Kubernetes

In Kubeflow’s [user surveys](https://medium.com/kubeflow/kubeflow-community-user-survey-fall-2019-a84776c71743), data scientists have consistently expressed the importance of Jupyter notebooks. Further, they need the ability to integrate isolated Jupyter notebooks with the efficiencies of Kubernetes on Cloud to train larger models using GPUs and run multiple experiments in parallel. Kubeflow makes it easy to leverage Kubernetes for resource management and put the full power of your datacenter at the fingertips of your data scientist.

With Kubeflow, each data scientist or team can be given their own namespace in which to run their workloads. Namespaces provide security and resource isolation. Using [Kubernetes resource quotas](https://kubernetes.io/docs/concepts/policy/resource-quotas/#compute-resource-quota), platform administrators can easily limit how much resources an individual or team can consume to ensure fair scheduling.

After deploying Kubeflow, users can leverage Kubeflow’s central dashboard for launching notebooks:

![Kubeflow’s UI for managing notebooks: view and connect to existing notebooks or launch a new one.](https://cdn-images-1.medium.com/max/2000/0*a0fExGwBs6pbAUDC)*Kubeflow’s UI for managing notebooks: view and connect to existing notebooks or launch a new one.*

In the Kubeflow UI users can easily launch new notebooks by choosing one of the pre-built docker images for Jupyter or entering the URL of a custom image. Next, users can set how many CPUs and GPUs to attach to their notebook. Notebooks can also include configuration and secrets parameters which simplify access to external repositories and databases.

![](https://cdn-images-1.medium.com/max/2000/0*U4dUF2N-w5LBxaJk)

### Training faster with distributed training

Distributed training is the norm at Google ([blog](https://ai.googleblog.com/2016/04/announcing-tensorflow-08-now-with.html)), and one of the most exciting and requested features for deep learning frameworks like TensorFlow and PyTorch.

When we started Kubeflow, one of our key motivations was to leverage Kubernetes to simplify distributed training. Kubeflow provides Kubernetes custom resources that make distributed training with TensorFlow and PyTorch simple. All a user needs to do is define a TFJob or PyTorch resource like the one illustrated below. The custom controller takes care of spinning up and managing all of the individual processes and configuring them to talk to one another:

```yaml
apiVersion: kubeflow.org/v1
kind: TFJob
metadata:
  name: mnist-train
spec:
  tfReplicaSpecs:
    Chief:
      replicas: 1
        spec:
          containers:
            image: gcr.io/alice-dev/fairing-job/mnist
            name: tensorflow
    Ps:
      replicas: 1
      template:
        spec:
          containers:
            image: gcr.io/alice-dev/fairing-job/mnist
            name: tensorflow
    Worker:
      replicas: 10
        spec:
          containers:
            image: gcr.io/alice-dev/fairing-job/mnist
            name: tensorflow
```

### Monitoring Model Training With TensorBoard

To train high quality models, data scientists need to debug and monitor the training process with tools like [Tensorboard](https://www.tensorflow.org/tensorboard). With Kubernetes and Kubeflow, userscan easily deploy TensorBoard on their Kubernetes cluster by creating YAML files like the ones below. When deploying TensorBoard on Kubeflow, users can take advantage of Kubeflow’s AuthN and AuthZ integration to securely access TensorBoard behind Kubeflow’s ingress on public clouds:

    // On GCP: [https://${KFNAME}.endpoints.${PROJECT}.cloud.goog/mnist/kubeflow-mnist/tensorboard/](https://${KFNAME}.endpoints.${PROJECT}.cloud.goog/mnist/kubeflow-mnist/tensorboard/)

    // On AWS:
    [http://8fb34ebe-istiosystem-istio-2af2-925939634.us-west-2.elb.amazonaws.com/mnist/anonymous/tensorboard/](http://8fb34ebe-istiosystem-istio-2af2-925939634.us-west-2.elb.amazonaws.com/mnist/anonymous/tensorboard/)

No need to `kubectl port-forward` to individual pods.

## Deploying Models

[KFServing](https://www.kubeflow.org/docs/components/serving/kfserving/) is a custom resource built on top of [Knative](https://knative.dev/) for deploying and managing ML models. KFServing offers the following capabilities not provided by lower level primitives (e.g. Deployment):

1. Deploy your model using out-of-the-box model servers (no need to write your own flask app)

1. Auto-scaling based on load, even for models served on GPUs

1. Safe, controlled model rollout

1. Explainability (alpha)

1. Payload logging (alpha)

Below is an example of a KFServing spec showing how a model can be deployed. All a user has to do is provide the URI of their model file using storageUri:

```yaml
apiVersion: "serving.kubeflow.org/v1alpha2"
kind: "InferenceService"
metadata:
  name: "sklearn-iris"
spec:
  default:
    predictor:
      sklearn:
        storageUri: "gs://kfserving-samples/models/sklearn/iris"
```

Check out the [samples ](https://github.com/kubeflow/kfserving/tree/master/docs/samples)to learn how to use the above capabilities.

## Solutions are More Than Models

A model gathering dust in object storage isn’t doing your organization any good. To put ML to work, you typically need to incorporate that model into an application – whether it’s a web application, mobile app, or part of some backend reporting pipeline.

Frameworks like flask and bootstrap make it easy for data scientists to create rich, visually appealing web applications that put their models to work. Below is a screenshot of the UI we built for Kubeflow’s [mnist example](https://github.com/kubeflow/examples/tree/master/mnist).

With Kubeflow, there is no need for data scientists to learn new concepts or platforms to deploy their applications, or to deal with ingress, networking certificates, etc. They can deploy their application just like TensorBoard; the only thing that changes is the Docker image and flags.

![](https://cdn-images-1.medium.com/max/2000/0*l3uPs-HtSF2TH3t0)

If this sounds like just what you are looking for we recommend:

1. Visiting our [docs](https://www.kubeflow.org/) to learn how to deploy Kubeflow on your public or private cloud.

2. Walking through the [mnist tutorial ](https://github.com/kubeflow/examples/tree/master/mnist)to try our core applications yourself.

## What’s coming in Kubeflow

There’s much more to Kubeflow than what we’ve covered in this blog post. In addition to the applications listed here, we have a number of applications under development:

* [Pipelines](https://www.kubeflow.org/docs/pipelines/overview/pipelines-overview/) (beta) for defining complex ML workflows

* [Metadata](https://www.kubeflow.org/docs/components/metadata/) (beta) for tracking datasets, jobs, and models,

* [Katib](https://www.kubeflow.org/docs/components/hyperparameter-tuning/hyperparameter/) (beta) for hyper-parameter tuning

* Distributed operators for other frameworks like [xgboost](https://github.com/kubeflow/xgboost-operator)

In future releases we will be graduating these applications to 1.0.

## User testimonials

All this would be nothing without feedback from and collaboration with our users. Some feedback from people using Kubeflow in production include:

*“The Kubeflow 1.0 release is a significant milestone as it positions Kubeflow to be a viable ML Enterprise platform. Kubeflow 1.0 delivers material productivity enhancements for ML researchers.” — *Jeff Fogarty, AVP ML / Cloud Engineer, **US Bank**

*“Kubeflow’s data and model storage allows for smooth integration into CI/CD processes, allowing for a much faster and more agile delivery of machine learning models into applications.” — *Laura Schornack**, **Shared Services Architect,** Chase Commercial Bank**

*“With the launch of Kubeflow 1.0 we now have a feature complete end-to-end open source machine learning platform, allowing everyone from small teams to large unicorns like Gojek to run ML at scale.” — *Willem Pienaar, Engineering Lead, Data Science Platform, **GoJek**

*“Kubeflow provides a seamless interface to a great set of tools that together manages the complexity of ML workflows and encourages best practices. The Data Science and Machine Learning teams at Volvo Cars are able to iterate and deliver reproducible, production grade services with ease.”— *Leonard Aukea, **Volvo Cars**

*“With Kubeflow at the heart of our ML platform, our small company has been able to stack models in production to improve CR, find new customers, and present the right product to the right customer at the right time.”* *— *Senior Director, **One Technologies**

*“Kubeflow is helping GroupBy in standardizing ML workflows and simplifying very complicated deployments!”* *— *Mohamed Elsaied, Machine Learning Team Lead, **GroupBy**

## Thank You!

None of this would have been possible without the tens of organizations and hundreds of individuals that have been developing, testing, and evangelizing Kubeflow.

![](https://cdn-images-1.medium.com/max/2000/0*KJc62AjAF91qNTyS)

## **An Open Community**

We could not have achieved our milestone without an incredibly active community. Please come aboard!

* Join the [Kubeflow Slack channel](https://kubeflow.slack.com/join/shared_invite/enQtNDg5MTM4NTQyNjczLTdkNTVhMjg1ZTExOWI0N2QyYTQ2MTIzNTJjMWRiOTFjOGRlZWEzODc1NzMwNTMwM2EzNjY1MTFhODczNjk4MTk)

* Join the [kubeflow-discuss](https://groups.google.com/forum/#!forum/kubeflow-discuss) mailing list

* Attend a [weekly community meeting](https://github.com/kubeflow/community)

* If you have questions, run into issues, please leverage the Slack channel and/or submit bugs via Kubeflow on GitHub.

Thank you all so much — onward!

repository: castrojo/blog

repo_name: castrojo/blog


text:
# Ghost Operator

The Ghost Operator is an implementation of a [Kubernetes Operator](https://kubernetes.io/docs/concepts/extend-kubernetes/operator/) using [Operator SDK](https://github.com/operator-framework/operator-sdk) for [Ghost](https://ghost.org/) headless CMS for professional publishing.

## Project Status

This project is currently work-in-progress and in Alpha, so it may not be production ready.

## Getting Started

> We assume you already have a running cluster

To install the operator, run:

```bash
kubectl create -f https://raw.githubusercontent.com/fossildev/ghost-operator/master/deploy/crds/ghost.fossil.or.id_ghostapps_crd.yaml
kubectl create -f https://raw.githubusercontent.com/fossildev/ghost-operator/master/deploy/service_account.yaml
kubectl create -f https://raw.githubusercontent.com/fossildev/ghost-operator/master/deploy/role.yaml
kubectl create -f https://raw.githubusercontent.com/fossildev/ghost-operator/master/deploy/role_binding.yaml
kubectl create -f https://raw.githubusercontent.com/fossildev/ghost-operator/master/deploy/operator.yaml
```

Once the `ghost-operator` deployment is ready, create a GhostApp instance, like:

```bash
kubectl apply -f - << EOF
apiVersion: ghost.fossil.or.id/v1alpha1
kind: GhostApp
metadata:
  name: example-ghostapp
spec:
  replicas: 1
  image: ghost:3
  config:
    url: http://ghost.example.com
    database:
      client: sqlite3
      connection:
        filename: /var/lib/ghost/content/data/ghost.db
  persistent:
    enabled: true
    size: 10Gi
  ingress:
    enabled: true
    hosts:
    - "ghost.example.com"
    - "www.ghost.example.com"
EOF
```

In this example, the Ghost App is available at http://ghost.example.com and Ghost Admin at http://ghost.example.com/ghost/

## Contributions

We hope you'll get involved! Read our [Contributors' Guide](CONTRIBUTING.md) for details.

## License

This project is licensed under the Apache-2.0 License - see the [LICENSE](LICENSE) for details

repository: fossildev/ghost-operator

gha_language: Go

repo_name: fossildev/ghost-operator


text:
---
name: Create a reference
example: octokit.rest.git.createRef({ owner, repo, ref, sha })
route: POST /repos/{owner}/{repo}/git/refs
scope: git
type: API method
---

# Create a reference

Creates a reference for your repository. You are unable to create new references for empty repositories, even if the commit SHA-1 hash used exists. Empty repositories are repositories without branches.

```js
octokit.rest.git.createRef({
  owner,
  repo,
  ref,
  sha,
});
```

## Parameters

      name
      required
      description

owner	yes

The account owner of the repository. The name is not case sensitive.

repo	yes

The name of the repository without the `.git` extension. The name is not case sensitive.

ref	yes

The name of the fully qualified reference (ie: `refs/heads/master`). If it doesn't start with 'refs' and have at least two slashes, it will be rejected.

sha	yes

The SHA1 value for this reference.

See also: [GitHub Developer Guide documentation](https://docs.github.com/rest/reference/git#create-a-reference).

gha_language: TypeScript


text:
# SPDY Test server

A simple server that returns some JSON that's consumed by a
[SPDY client](https://github.com/marcoow/spdy-test-client); run with

```
bundle exec rackup
```

You need to have Nginx with support for SPDY 3.1 installed. On Mac OS, it's
best to install it with homebrew:

```bash
brew install nginx --with-spdy --HEAD
```

Find the Nginx configuration along with the certificate and key in the `nginx`
directory.

license: Unlicense

repository: marcoow/spdy-test-server

repo_name: marcoow/spdy-test-server


text:
## 113.33.00

- Add an option `~close_stdout_and_stderr` to `Async_parallel_deprecated.Std.Parallel.init`
  to close the `stdout` & `stderr` fds.

  This is needed when using `Async_parallel_deprecated` in a daemonized processes, such as
  the in-development jenga server.

  Without this option, Calling ` Process.run ~prog:"jenga" ~args:`"server";"start"` ` from
  build-manager is problematic because the resulting deferred never becomes determined.

## 113.24.00

- Switched to ppx.

## 112.35.00

- Renamed `Async_parallel` as `Async_parallel_deprecated`; one should
  use `Rpc_parallel` instead.

## 112.17.00

- Modernize the code

## 111.25.00

- improve error handling

## 109.41.00

Rename library from Parallel to Async_parallel


text:
---
layout: post
title: Announcing first ever... blog post!
comments: true
tags: awesome wow
---

![My pic](/public/my-pic-small.jpg)

### What's this?

My very interesting post about:

* Nothing.
* Not much.
* Nada.
* Zilch.

### Check out my code

You can highlight `code elements` with backquotes.

{% highlight scala linenos %}
// Meaningful comment

val bob: String = "bob"
{% endhighlight %}

{% gist 5555251 %}

### And now...

Well, the way they make shows is, they make one show. That show's called a pilot. Then they show that show to the people who make shows, and on the strength of that one show they decide if they're going to make more shows. Some pilots get picked and become television programs. Some don't, become nothing. She starred in one of the ones that became nothing.

* Toggleable sliding sidebar (built with only CSS) via **☰** link in top corner
* Sidebar includes support for textual modules and a dynamically generated navigation with active link support
* Two orientations for content and sidebar, default (left sidebar) and [reverse](https://github.com/poole/lanyon#reverse-layout) (right sidebar), available via `<body>` classes
* [Eight optional color schemes](https://github.com/poole/lanyon#themes), available via `<body>` classes

[Head to the readme](https://github.com/poole/lanyon#readme) to learn more.

### Lorem Ipsum

Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.

### Eh?

Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.

Thanks!
{% include twitter_plug.html %}


text:
# Running in Production

This page will discuss the various added functionality you might need for running Seldon Core in a production environment.

 * [Pulling from Private Docker Registries](private_registries.md)
 * [gRPC max message size](grpc_max_message_size.md)

repository: rangsansith/seldon-core

repo_name: rangsansith/seldon-core


text:
# subzero-shared

This library encapsulates the logic needed for interacting with subzero.  It is designed for use in
our coordinator service, and in our integration tests.

## API
For more information on each of these methods, see their relevant Javadocs.  This is a high level
overview of this library.  There's two main classes here.

### ColdWalletCreator

ColdWalletCreator handles the creation of a new cold wallet.  There are two offline steps to this
process (InitWallet and FinalizeWallet), which are handled by three static functions here.

The setup flow looks like this:
1. `ColdWallet.init()` returns an `InitWalletRequest`
2. Subzero runs InitWalletRequest and return `InitWalletResponse`
3. `ColdWallet.combine()` on the `InitWalletResponse ` returning `FinalizeWalletRequest`s
4. Subzero runs `FinalizeWalletRequest` and return `FinalizeWalletResponse`s
5. `ColdWallet.finalize()` on those `FinalizeWalletResponse` to obtain the public keys

### ColdWallet

To use a cold wallet, you pass the public keys from setup and other parameters to the ColdWallet
constructor.  The ColdWallet object is for sending money to and from the cold wallet.

`ColdWallet.address` takes a derivation path and returns an address that can be used to send funds
to the wallet.  The derivation path should be saved for use in withdrawing those funds.

Creating a transaction is a two-step process, where the coordinator starts a transaction, it is
signed offline, and then those signatures are combined to produce the final transaction.

`ColdWallet.startTransaction` is for for starting moving money in cold storage.  It creates the
 SendTxRequest command to send to cold storage for signing.  This is called once, and the resulting
 SignTxRequest is distributed to the signers.

 `ColdWallet.createTransaction` takes the signatures from cold storage, along with the parameters
 passed to the corresponding startTransfer, and produces the final transaction for broadcast.  This
 requires input from the required number of participants (ie, 2 of 4).

 ### Constants

 A class with various constants.

 ### SubzeroUtils

This is a grab-bag of stuff, used for implementing the above classes.  Ideally the implementation
details here should be considered private and we have a nice API to hand off.

repository: square/subzero

repo_name: square/subzero


text:
# ld-find-code-refs

Command line program for generating flag code references.

This repository provides solutions for configuring [LaunchDarkly code references](hhttps://docs.launchdarkly.com/v2.0/docs/git-code-references) with various systems out-of-the-box, as well as the ability to automate code reference discovery on your own infrastructure using the provided command line interface.

## Configuration options

We provide turnkey support for common trigger mechanisms and CI / CD providers. You can also invoke the ld-find-code-refs utility from the command line, which can be run in any custom workflow you define (e.g. from a bash script, or a cron job).

| System | Status |
|---------------------|---------------------------------------------------------------------------------------------------------|
| GitHub Actions | [Supported](https://docs.launchdarkly.com/v2.0/docs/github-actions) |
| CircleCI Orbs | [Supported](https://docs.launchdarkly.com/v2.0/docs/circleci-orbs) |
| BitBucket Pipelines | [Supported](https://docs.launchdarkly.com/v2.0/docs/bitbucket-pipelines-coderefs)
| Manually via CLI | [Supported](https://docs.launchdarkly.com/v2.0/docs/custom-configuration-via-cli) |
| AWS Lambda jobs | Planned |

## Execution via CLI

The command line program may be run manually, and executed in an environment of your choosing. The program requires your `git` repo to be cloned locally, and the currently checked out branch will be scanned for code references.

### Installing

#### macOS

```shell
brew tap launchdarkly/tap
brew install ld-find-code-refs
```

You can now run `ld-find-code-refs`.

#### Linux
We do not yet have repositories set up for our linux packages, but we do upload deb and rpm packages with our github releases.

##### Ubuntu
This shell script can be used to download and install `ag` and `ld-find-code-refs` on Ubuntu.

```shell
apt-get install silversearcher-ag

wget -qO- https://api.github.com/repos/launchdarkly/ld-find-code-refs/releases/latest \
	| grep "browser_download_url" \
	| grep "amd64.deb" \
	| cut -d'"' -f4 \
	| wget -qi - -O ld-find-code-refs.amd64.deb

dpkg -i ld-find-code-refs.amd64.deb
```

#### Manual

Precompiled binaries for the latest release can be found [here](https://github.com/launchdarkly/ld-find-code-refs/releases/latest).

The `ld-find-code-refs` program requires [Git](https://git-scm.org) and [The Silver Searcher](https://github.com/ggreer/the_silver_searcher#installing) to be installed as a dependency, so make sure these dependencies have been installed and added to your system path before running `ld-find-code-refs`.

### Examples

The section provides examples of various `bash` commands to execute `ld-find-code-refs` (when installed in the system PATH) with various configurations. We recommend reading through the following examples to gain an understanding of common configurations, as well as the detailed sections below documenting advanced configuration options.

 If < 0, no source code will be sent to LD
```

The above configuration, with the `vendor/` directory and all `css` files ignored by the scanner. The `exclude` parameter may be configuration as any regular expression that matches the files and directories you'd like to ignore for your repository:

```bash
ld-find-code-refs \
  -accessToken="$YOUR_LAUNCHDARKLY_ACCESS_TOKEN" \
  -projKey="$YOUR_LAUNCHDARKLY_PROJECT_KEY" \
  -repoName="$YOUR_REPOSITORY_NAME" \
  -dir="/path/to/git/repo" \
  -contextLines=3
  -exclude="vendor/|\.css" # replace with desired regex pattern
```

A configuration with the the `repoType` set to GitHub, and the `repuUrl` set to a GitHub URL. We recommend configuring these parameters so LaunchDarkly is able to generate reference links to your source code:

```bash
ld-find-code-refs \
  -accessToken="$YOUR_LAUNCHDARKLY_ACCESS_TOKEN" \
  -projKey="$YOUR_LAUNCHDARKLY_PROJECT_KEY" \
  -repoName="$YOUR_REPOSITORY_NAME" \
  -dir="/path/to/git/repo" \
  -contextLines=3
  -repoType="github"
  -repoUrl="$YOUR_REPOSITORY_URL" # example: https://github.com/launchdarkly/ld-find-code-refs
```

### Required arguments

A number of command-line arguments are available to the code ref finder, some optional, and some required. Command line arguments may be passed to the program in any order.

| Option | Description |
|-|-|
| `accessToken` | LaunchDarkly [personal access token](https://docs.launchdarkly.com/docs/api-access-tokens) with writer-level access, or access to the `code-reference-repository` [custom role](https://docs.launchdarkly.com/v2.0/docs/custom-roles) resource |
| `dir` | Path to existing checkout of the git repo. The currently checked out branch will be scanned for code references. |
| `projKey` | A LaunchDarkly project key. |
| `repoName` | Git repo name. Will be displayed in LaunchDarkly. Repo names must only contain letters, numbers, '.', '_' or '-'." |

### Optional arguments

Although these arguments are optional, a (*) indicates a recommended parameter that adds great value if configured.

| Option | Description | Default |
|-|-|-|
| `baseUri` | Set the base URL of the LaunchDarkly server for this configuration. Only necessary if using a private instance of LaunchDarkly. | `https://app.launchdarkly.com` |
| `contextLines` (*) | The number of context lines to send to LaunchDarkly. If < 0, no source code will be sent to LaunchDarkly. If 0, only the line containing flag references will be sent. If > 0, will send that number of context lines above and below the flag reference. A maximum of 5 context lines may be provided. | `2` |
| `debug` | Enables verbose debug logging. | `false` |
| `defaultBranch` | The git default branch. The LaunchDarkly UI will default to display code references for this branch. | `master` |
| `exclude` (*) | A regular expression (PCRE) defining the files and directories which the flag finder should exclude. Partial matches are allowed. Examples: `vendor/`, `\.css`, `vendor/\|\.css` | |
| `updateSequenceId` | An integer representing the order number of code reference updates. Used to version updates across concurrent executions of the program. If not provided, data will always be updated. If provided, data will only be updated if the existing `updateSequenceId` is less than the new `updateSequenceId`. Examples: the time a `git push` was initiated, CI build number, the current unix timestamp. | |
| `repoType` (*) | The repo service provider. Used to generate repository links in the LaunchDarkly UI. Acceptable values: github\|bitbucket\|custom | `custom` |
| `repoUrl` (*) | The display url for the repository. If provided for a github or bitbucket repository, LaunchDarkly will attempt to automatically generate source code links. Example: `https://github.com/launchdarkly/ld-find-code-refs` | |
| `commitUrlTemplate` | If provided, LaunchDarkly will attempt to generate links to your Git service provider per commit. Example: `https://github.com/launchdarkly/ld-find-code-refs/commit/${sha}`. Allowed template variables: `branchName`, `sha`. If `commitUrlTemplate` is not provided, but `repoUrl` is provided and `repoType` is not custom, LaunchDarkly will automatically generate links to the repository for each commit. | |
| `hunkUrlTemplate` | If provided, LaunchDarkly will attempt to generate links to your Git service provider per code reference. Example: `https://github.com/launchdarkly/ld-find-code-refs/blob/${sha}/${filePath}#L${lineNumber}`. Allowed template variables: `sha`, `filePath`, `lineNumber`. If `hunkUrlTemplate` is not provided, but `repoUrl` is provided and `repoType` is not custom, LaunchDarkly will automatically generate links to the repository for each code reference.  | |

repository: iynere/ld-find-code-refs

repo_name: iynere/ld-find-code-refs


text:
Raspberry-Pi-Car
================

The software used to create a browser-based remote control car with joystick control, live video and speech synthesis. A youtube video demonstrating this robot is available at https://www.youtube.com/watch?v=F3hmwtnsWZA.

<img src="http://i.imgur.com/WngRSn2.png" height="350" width="auto" alt="Raspberry Pi Car"/>

PS. This project uses the awesome [virtualjoystick.js](https://github.com/jeromeetienne/virtualjoystick.js) and [jQuery](http://jquery.com/) *(Both of which are licensed under the MIT license)*.

##How The Software Works

The robot uses the following pieces of software in the following ways:

- `node.js` - serves the webpage to the user. It also recieves messages about the controls and activates the gpio ports on the raspberry pi accordingly. (access the server over port 8090 by default)

- `mjpg-streamer` - provides a streaming jpg image which is embedded in the webpage that is served to the user. This allows the user to see through the webcam attached to the robot. (streams over port 8091)

- `pi-blaster` - allows the node.js server to send PWM signals to the GPIO pins on the raspberry pi. PWM has advantages over simple high and low signals because it allows us to control the speeds of each motor, allowing for dynamic turning/speed changes. It should be noted that if speech synthesis is required, the pi-blaster software should be started in PCM mode as opposed to PWM mode to prevent interference with audio output on the pi. PCM mode is enabled by the startrobot script.

- `festival` - the node.js server runs bash commands which in turn use festival to synthesize speech.

##Physical Setup of the Robot

The robot uses 4 GPIO pins for output to the motors, and the ground port on the raspberry pi. The gpio pins used are as follows

```
Right motor - 4, 17
Left motor - 22, 23
flashlight - 24
```

Trial and error is the easiest way to determine which way round the pins should go to spin the motors in the correct directions.

##Scripts and Their Purposes

There are 4 scripts in the main directory which start all of the software required for the robot to run. They have the following purposes:

`mjpgserverrunner.sh` - runs the mjpgserver. The contents of the script can be altered to change the resolution that the mjpg streams at (default: 320x240)

`piblasterpcm.sh` - changes pi-blaster from PWM to PCM mode so that it doesn't interfere with audio output on the raspberry pi.

`nodeserverrunner.sh` - runs the node.js server with the app nodeserver/app.js.

`startrobot` - this script simply runs all of the other scripts in the correct order. It calls the scripts in the following order: piblasterpcm.sh, mjpgserverrunner.sh, nodeserverrunner.sh

##Software installation

All of the install scripts made reference to can be found in the "Installation" folder.

1.  Install node.js and the following modules:
  - `socket.io`
  - `node-static`
  - `sleep`
  - `pi-blaster.js`
  - `optimist`

*(Install the raspberry pi specific version from the repo. don't use apt-get - you might run in to compilation problems when installing or using modules.)*

*(NOTE: The `NODESERVERRUNNER.SH` script relies on the node executable being in a specific directory. In your setup the serverrunner script will likely not point to the right place. simply change the appropriate line within the script to point to your node executable.)*

2.  Make sure you have autoconf installed (use apt-get). Run the pi-blaster installation script. This will install pi-blaster in to the parent directory in the folder pi-blaster.

*(NOTE: The `PIBLASTERPCM.SH` script relies on the pi-blaster executable being in a specific directory `/home/pi/pi-blaster/pi-blaster.sh`. If it can't be found as this location, change the script to point to the right place.)*

3.  Run the `mjpgsetup.sh` script in the installation folder. It will install the server so it can be accessed system-wide with the command mjpg_streamer.

4.  to use voice synthesis, install `festival` voice synthesis using apt-get.

5. run the `startrobot` script to start all software components necessary for the robot to function.

*(NOTE: The `startrobot` command relies on the password for the current user being "raspberry" (default for a raspberry pi). If it is not this, change te script accordingly.)*

repository: dnessorga/Raspberry-Pi-Car

repo_name: dnessorga/Raspberry-Pi-Car


text:
# HighSierraMailPrefs

Submodule for Mail plugins to use to coordinate working with plugin preferences

In High Sierra, Apple has changed the way it deals with preferences, migrating from a "NSPreference Module" approach to a NSWindowController with NSTabViews

With  the change, it is a little trickier for plugins to get into the preferences and to play cooperatively with other plugins

Because of this, we have created code and a few techniques for plugins to play nicely together and to assist with the loading of plugins.  With the added bonus of being able to leverage old ways of handling preferences to avoid signficiant code rewrites and cross version compatiblity issues.

We have added 2 swizzles

### [MailApp setPreferencesController:]

This is called when Mail opens the preferences window and registers the newly created window controller with the App.

We swizzle this as this is the best point to add the extra preferences view controllers for the plugins.

### [MailTabViewController setSelectedTabViewItemIndex:]

This is called when the user switches preferences views.

We swizzle this to adjust the geometry of the window to allow different sizes for plugin preferences views.

Both swizzles are meant to be dropped into your plugins without modifications (except for the method names).  They are designed so that if the code remains unchanged, it will ensure the work of adding plugins, changing geometry only happens once even though there may be many plugins installed.  (so long as all these plugins adhere to the methodology)

---

## Instructions

1. Clone the HSMailPrefs repository as a submodule to your current working copy
2. Add the subfolder "HSMailPrefs" to your project.  (This is the folder that contains HSMailPreSwizzle.h file)
3. Make sure that all the following implementation files are added to your target:

> * `HSMailPrefSwizzle.m`
> * `MailApp_HSMailPrefs.m`
> * `MailTabViewController_HSMailPrefs.m`

( Note that these need ARC to Build so set add compiler flag `-fojbc-arc`  if your project isn't ARC)

4. Add a preprocessor macro to your build settings
            `PLUGIN_ID=XXX` where XXX is your usual plugin id  (eg MT for MailTags, MAO for MailPerspectives)

That's it.  Build and run.

The code take care of its own swizzling and will make ensure that it won't collide with other plugins (so long as the values for PLUGIN_ID are different).

### Adding a PluginPreferenceViewController

Now that Mail's individual plugin panes are controlled by NSViewControllers rather than NSPreferences objects, You may will need to create  your own PluginPreferenceViewController.  We added a `PluginPreferencesViewController` protocol (in PluginPreferencesViewController.h)

There is a `SamplePluginViewController.h/.m` for you to model your on.

In addition to the @required methods of the protocol, the preferencesViewController will need to register itself to be recognized by our code for loading preferences.

To do this you must
`#import "MailApp_HSMailPrefs.h"`

and then call  `[MailApp_HSMailPrefs registerPluginPreferenceViewControllerClass:self];` in your preferencesViewController `+load` method.

```
+(void)load{
    // register this PluginPreferenceViewController class
    [MailApp_HSMailPrefs registerPluginPreferenceViewControllerClass:self];
}
```

If you want to you reuse your Preferences controllers from 10.12 and earlier, you can store init and store an instance of it in the new view controller.  See `SamplePluginViewController.m` for an example.

repository: Smallcubed/HighSierraMailPrefs

gha_language: Objective-C

repo_name: Smallcubed/HighSierraMailPrefs


text:
PdfPasswordRemover
====================================

PdfPasswordRemover is a project to remove passwords from PDF files.

[![Build status](https://ci.appveyor.com/api/projects/status/fg7oe6kh4vyqltbo?svg=true)](https://ci.appveyor.com/project/SeppPenner/pdfpasswordremover)
[![GitHub issues](https://img.shields.io/github/issues/SeppPenner/PdfPasswordRemover.svg)](https://github.com/SeppPenner/PdfPasswordRemover/issues)
[![GitHub forks](https://img.shields.io/github/forks/SeppPenner/PdfPasswordRemover.svg)](https://github.com/SeppPenner/PdfPasswordRemover/network)
[![GitHub stars](https://img.shields.io/github/stars/SeppPenner/PdfPasswordRemover.svg)](https://github.com/SeppPenner/PdfPasswordRemover/stargazers)
[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://raw.githubusercontent.com/SeppPenner/PdfPasswordRemover/master/License.txt)
[![Known Vulnerabilities](https://snyk.io/test/github/SeppPenner/PdfPasswordRemover/badge.svg)](https://snyk.io/test/github/SeppPenner/PdfPasswordRemover)

# Screenshots from the GUI
![Screenshot from the GUI German](https://github.com/SeppPenner/PdfPasswordRemover/blob/master/Screenshot_DE.PNG "Screenshot from the GUI German")
![Screenshot from the GUI English](https://github.com/SeppPenner/PdfPasswordRemover/blob/master/Screenshot_EN.PNG "Screenshot from the GUI English")

# For more information see
* https://www.codeproject.com/Articles/31493/PDF-Security-Remover
* http://www.pdfsharp.net/wiki/UnprotectDocument-sample.ashx?AspxAutoDetectCookieSupport=1
* http://pdfsharp.com/PDFsharp/index.php?option=com_content&task=view&id=39&Itemid=50
* https://stackoverflow.com/questions/19565078/itextsharp-open-password-protected-file-modify-it-and-adopt-protection
* http://kuujinbo.info/iTextInAction2Ed/index.aspx?ch=Chapter12&ex=EncryptionPdf
* https://memorynotfound.com/encrypt-decrypt-password-protected-pdf-documents-itext/

Change history
--------------

See the [Changelog](https://github.com/SeppPenner/PdfPasswordRemover/blob/master/Changelog.md).

repository: SeppPenner/PdfPasswordRemover

repo_name: SeppPenner/PdfPasswordRemover


text:
# chain-ko-validation-rules
Chain [knockout.js validation rules](https://github.com/Knockout-Contrib/Knockout-Validation/wiki/Async-Rules) (async and non-async), ensuring their sequential execution.

To be used with [knockout.validation](https://www.npmjs.com/package/knockout.validation) package.

## Usage:

~~~js

import ko from 'knockout';
import koValidation from 'ko.validation';
import chainKoValidationRules from 'chain-ko-validation-rules';

const combinedRule = chainKoValidationRules([
	{
		async: true,
		validator: function(val, otherVal, callback) {
			// validation logic
		},
		message: 'Some validation error message'
	},
	{
		async: true,
		validator: function(val, otherVal, callback) {
			// validation logic
		},
		message: 'Some other validation error message'
	},
	// ... more async or non-async rules
]);

ko.observable().extend({validation: combinedRule});

~~~

repository: iredchuk/chain-ko-validation-rules

repo_name: iredchuk/chain-ko-validation-rules


text:
# swift-handy
Handy Swift Helper belong here, Including my unfinish/use at risk helper.
### Structure
```
/ProjectName
	/m			# Models, Core Data schema etc
	/v			# Shared views
	/c			# Base view controllers
	/s			# Services
	/Library		# Anything that falls outside of the MVC pattern
	/Support		# Categories and helpers

	/iPhone
		/m		# Models, Core Data schema etc
		/v		# Shared views
		/c		# Base view controllers
		/Library	# Anything that falls outside of the MVC pattern
		/Support	# Categories and helpers

	/iPad
		/m		# Models, Core Data schema etc
		/v		# Shared views
		/c		# Base view controllers
		/Library	# Anything that falls outside of the MVC pattern
		/Support	# Categories and helpers

	/Other source		# Prefix headers, main.m
	/Supporting file	# Info.plist

/Resources              	# Images, videos, .strings files
/Vendor                 	# 3rd party dependencies not managed by CocoaPods
/Scripts                	# All project-related scripts, typically executed as rake tasks.
/Translation			# Holds all the base strings and localized
/Pods				# Folder containing all dependency CocoaPods.
```
### CocoaPods
* Create `Podfile`
```shell
platform :ios, '8.0'
use_frameworks!

pod 'Signals', '~> 1.0'
```
and then
```shell
$ pod install
```
### Async
* https://github.com/inamiy/Await

### Promise
* https://github.com/mxcl/PromiseKit

### Signals
* https://github.com/artman/Signals

### JSON
* https://github.com/SwiftyJSON/SwiftyJSON
```swift
// Note to self : Convert from string
let string = "{\n  \"foo\" : \"bar\"\n}"
let json = JSON(data:string.dataUsingEncoding(NSUTF8StringEncoding)!)
```

### Core
* https://github.com/pNre/ExSwift

### HTTP
* https://github.com/Alamofire/Alamofire

### NSUserDefaults
* https://github.com/radex/SwiftyUserDefaults
```swift
// Note to self : Complex use
Defaults["bar"] = NSKeyedArchiver.archivedDataWithRootObject([100:"foo", 2:"b", 3:["foo":"bar"]])
let bar: AnyObject? = NSKeyedUnarchiver.unarchiveObjectWithData(Defaults["bar"].data!)
println(bar)
```

### Colors
* https://github.com/katopz/google-material-color-swift

### Date
* https://github.com/akosma/SwiftMoment

### Time
* https://github.com/radex/SwiftyTimer

### Helper
* KZBlock
```swift
primus.on("open", listener : KZBlock<@objc_block () -> ()> {
    let _ = primus.write(["event": "roomAdd", "room": "defaultRoom"])
}.casted)

primus.on("data", listener : KZBlock<@objc_block (NSDictionary, AnyObject) -> ()> { (d: NSDictionary, raw: AnyObject) in
    NSLog("Got data: \(d)")
}.casted)
```

* KZPacker
```swift
let string = "{\"foo\":\"bar\"}"
let key = "foos"
var old_data = [1:string, 2:string, 3:string]
var new_data = [2:string, 4:string]

// save
KZPacker.pack(key, old_data)

// load
var data = KZPacker.unpack(key) as! [Int:String]
println("get    : \(data)")

// sort
var sorted_data = sorted(data) { $0.0 > $1.0 }
println("sorted : \(sorted_data)")

// merge
for item in new_data {
	old_data[item.0] = item.1
}
println("merged : \(old_data)")

// remove
println("remove : " + key)
KZPacker.remove(key)

if let del_data = KZPacker.unpack(key) as? [Int:String] {
    println(" This should not be seen : \(del_data)")
}
```

repository: katopz/swift-handy

repo_name: katopz/swift-handy


text:
# fh-cachekey-client

Simple CacheKey client for publishing, updating and removing cache keys with Millicore.

## Usage

var mcache = require('fh-cachekey-client')({
  millicore : {
    serviceKey : '1a2b...',
    url : 'http://testing.feedhenry.me'
  },
  rejectUnauthorized : true // passes to rejectUnauthorized property of request
})

## Tests
Unit tests:

  npm test

Acceptance tests (which don't run by default):

  ./node_modules/.bin/mocha -A -u exports --recursive -t 10000 test/test-accept.js

repository: feedhenry/fh-cachekey-client

gha_language: JavaScript

repo_name: feedhenry/fh-cachekey-client


text:
---
title: Adioma - Visual Icon Search
date: "2018-05-28T22:40:32.169Z"
coverImage: ./thumb/cover.jpg
thumbImage: ./thumb/thumb.jpg
---

I build visual icon search system based on visual language. The user could search based on common parts of the icons (radical) or keywords.

**Tech**: PHP, MySQL, Laravel, React, Elastic Search

**Scope**: development, product management

<iframe width="560" height="315" src="https://www.youtube.com/embed/nyFi0Cra0q0" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>

[Explore the project](https://adioma.com/icons)


text:
# Project BACnet (BAsel Citizen Net)

The Internet has become so ubiquitous that we take it for granted,
forgetting how much it depends on political goodwill:
Access restrictions are quite common worldwide, be it the “Chinese
firewall”, India cutting the Internet for Kashmir, or the Spanish
Police seizing the DNS name of the Catalan independence movement.

Our goal is to implement communication means that avoid this
dependency, yet support for example social media.

## Spring 2020

In spring 2020, BSc students of the lecture _Introduction to Internet
and Security_ at the [University of Basel](https://www.unibas.ch/)
built a first BACnet system from scratch.

Their source code is collected in this GitHub repository. A final
[113 page report (11MB)](20-fs-ias-lec/BACnet-Report-IAS-2020.pdf) was
compiled from all project reports.

## Fall 2020

The seminar "Internet Re-Decentralization" aims at extending the
first version of BACnet with Project like Secure Team Chat and
Double Ratchet Encryption.
A final [report](20-hs-redez-sem/BACnet-Report-Redez-2020.pdf) summarizes
the results of these Projects.

## Spring 2021

The next year of BSc students of the lecture _Introduction to Internet
and Security_ at the [University of Basel](https://www.unibas.ch/)
continue building on BACNet. Reports can be found [here](21-fs-ias-lec/README.md).

repository: cn-uofbasel/BACnet

gha_language: Python

repo_name: cn-uofbasel/BACnet


text:
# My Notes
Cloned from: https://github.com/StephenGrider/ReduxSimpleStarter.git

## setup
```
> npm install
> npm start
```

## take-aways
- uses chai-jquery to run the selectors
  - i'd prefer if it used Jest
- tests the end result, in this case: the html that ultimately renders
  - doesn't quite feel like a unit test

repository: pedro-mass/learn

repo_name: pedro-mass/learn


text:
## Redis Server on macOS

What is Redis?

	Redis is an open source (BSD licensed), in-memory data structure store,
	used as a database, cache and message broker. It supports data structures such as
	strings, hashes, lists, sets, sorted sets with range queries, bitmaps, hyperloglogs,
	geospatial indexes with radius queries and streams. Redis has built-in replication,
	Lua scripting, LRU eviction, transactions and different levels of on-disk
	persistence, and provides high availability via Redis Sentinel and automatic
	partitioning with Redis Cluster. Learn more https://redis.io/topics/introduction

### Download - Redis Server

	https://redis.io/download

### Installation - Redis Server

	To tar downloaded redis package
	-------------------------------
	$ tar xzf redis-5.0.7.tar.gz
	$ cd redis-5.0.7

	To compile binaries
	-------------------
	$ make

	Note: For 32 bit
	$ make 32bit

	To test compiled binaries
	-------------------------
	$ make test

### Start - Redis Server
	$ ./src/redis-server

### To test Redis Server connection
	$ ./src/redis-cli ping

	Note: Open new shell tab/windows

### Redis CLI built-in Client to interact with Redis Server
	$ ./src/redis-cli

### Set a Key & Value Pair into Redis Server through Redis CLI Client

	To test Redis Server connection
	<IP_ADDRESS>:6379> PING

	To set a value with an associated key
	<IP_ADDRESS>:6379> set dev_name "Rahamath S"

	To get a value with an already associated key
	<IP_ADDRESS>:6379> get dev_name

## Redis Desktop Manager as Client

### What is Redis Desktop Manager

	Redis Desktop Manager (aka RDM) — is a fast Redis database management application for Windows, Linux, MacOS and iPadOS.

### Download and Install Redis Desktop Manager

	Step 1: Download redis-desktop-manager-2019.5.181.dmg  from  https://redisdesktop.com/subscriptions

	Step 2: Install redis-desktop-manager-2019.5.181.dmg

	Step 3: After installation, open Redis Desktop Manager

	Step 4: Click on 'Connect to Redis Server'

	Step 5: Enter following Redis Server Connection Settings
			- Connection Name
			- Redis Server IP (default: <IP_ADDRESS>)
			- Redis Server Port (default: 6379)
			- Enter SSL, SSL Tunnel and other necessary details

	Step 6: Test Connection and click 'OK'

	Step 7: Left side click on the 'Connection Name' to extend and check the Keys & Values

## Refer following GitHub project for Java Client to connect with Redis Server

	https://github.com/rahamath18/Redis-Jedis-Java-Client-Example

## Note:

The MSOpenTech-Redis project is no longer being actively maintained. If you are looking for a Windows version of Redis, you may want to check out Memurai. Please note that Microsoft is not officially endorsing this product in any way. More details in https://github.com/microsoftarchive/redis

To install & setup Redis Server on Windows 10 https://redislabs.com/blog/redis-on-windows-10

To install & setup Redis Server on macOS & Linux https://redis.io/download

Also, you may install & setup Redis Server on Linux via the package manager

For quick Redis Server Installation & Setup Guide for macOS https://github.com/rahamath18/Redis-on-MacOS


text:
# Camp Fyre
A place to hang out and chat with your friends.

I started this project, after seeing Discord, and the massive amount of complaints they get, with no resolution, as well as with my own grievances.

This is still very much a work in progress, and nowhere near done.

If you would like to support development, you can donate [here](https://ko-fi.com/campfyre), and if you would like to participate in beta builds, or generally ask about the app, you can join our [Discord server](https://discord.gg/XhwwW9zkPx).

yes, I see the irony in mentioning Discord having problems and using a Discord server as a form of communication.

repository: CampFyreCo/Main

repo_name: CampFyreCo/Main


text:
To add a new proxy application:

- Say the proxyapp name is "XYZ"
- Using the apps.format.json create a new file apps-jsons/XYZ.json and fill in
  the details.
- Using the apps.format.md create a new file _apps/XYZ.md and fill in the file
  name XYZ.json in the file variable (Do not delete the "/proxy-apps/apps-jsons/"
  prefix).

repository: akhilpatlolla/proxy-apps

repo_name: akhilpatlolla/proxy-apps


text:
We are now going to move onto another practical application of variables and functions. We're going to handle the scoring for the game using a simple algorithm.

The game can handle the display of the following information

- **Steps** the number of moves your player has made
- **Energy** the amount of energy your player has
- **Score** the total score

## Rules of the game

- The player has a certain amount of starting energy, which you can decide, as we'll see later.
- You lose energy with each step you take.
- You gain energy when you hit an energy store.
- You lose energy when you brush up against a monster.

## Play
Play the game and see what happens to the score each time you take a step, hit an energy store or brush up against a monster. Keep an eye on the steps, energy and score displays.


text:
![Build status](https://travis-ci.org/Hgazibara/phunctional.svg)

phunctional
===========

A simple set of functions making functional programming in PHP easier. Code is
inspired by Haskell and Python, especially Python's modules [itertools](https://docs.python.org/2/library/itertools.html),
[functools](https://docs.python.org/2/library/functools.html), and [toolz](https://pypi.python.org/pypi/toolz/).

Another important intention is to create a single interface for arrays and strings. Strings can be converted to iterator using `phunctional\iter\istring` and then passed to `map()`, `slice()`, `count()` or any other method which works with iterable sequences. In the near future, similar thing will be possible with resources, too.

API List
=========

Until better documentation is created, here's a list of exposed functions:

```
<?php

// From phunctional\iter

boolean function isIterable($sequence)
\Generator function filter(callable $callback, $sequence)
\Generator function filterFalse(callable $callback, $sequence)
\Generator function map(callable $callback, $sequence)
\Generator function reduce(callable $callback, $sequence, $start = 0)
\Generator function sum($sequence, $start = 0)
mixed function product($sequence, $start = 1)
boolean function any($sequence)
boolean function all($sequence)
\Generator function cycle($sequence)
\Generator function range($start, $stop=null, $step = 1)
\Generator function repeat($item, $times)
\Generator function istring($string, $encoding='UTF-8')
\Generator function iter($sequence)
mixed function next(\Iterator $iterator, $default=null)
array function toArray($target)
\Generator function zip(/* mixed[] $sequences */)
\Generator function zipLongest(/* mixed[] $sequences */)
\Generator function slice($sequence, $start = 0, $length = null, $step = 1)
\Generator function drop($length, $sequence)
\Generator function take($lenth, $sequence)
mixed function second($sequence)
mixed function last($sequence)
mixed function nth($which, $sequence)
mixed function count($sequence)

// From phunctional\func

callable function partial(callable $fn /* mixed[] $args */)

// From phunctional\operators
callable operator($operator)
callable id()
callable not()
```

repository: Hgazibara/phunctional

repo_name: Hgazibara/phunctional


text:
1984 themes merge the base colour scheme, based on the "rainbow" Apple logo, with other colour schemes. This has the effect of making said schemes more neutral and clean, while mainting their character and uniqueness.

# 1984-base
![Xresources](1984-base/.Xresources)

![Colours](1984-base/pane.png)

Licence: ![MIT](https://github.com/felix-u/1984-themes/blob/master/LICENSE)

# 1984-dracula
![Xresources](1984-dracula/.Xresources)

![Colours](1984-dracula/pane.png)

Based on https://github.com/dracula/dracula-theme | Licence: ![MIT](https://github.com/dracula/dracula-theme/blob/master/LICENSE)

# 1984-gruvbox
![Xresources](1984-gruvbox/.Xresources)

![Colours](1984-gruvbox/pane.png)

Based on https://github.com/morhetz/gruvbox | Licence: ![MIT/X11](https://en.wikipedia.org/wiki/MIT_License)

# 1984-monokai
![Xresources](1984-monokai/.Xresources)

![Colours](1984-monokai/pane.png)

Based on https://github.com/kevinsawicki/monokai

# 1984-mountaineer
![Xresources](1984-mountaineer/.Xresources)

![Colours](1984-mountaineer/pane.png)

Based on https://github.com/co1ncidence/mountaineer.vim | Licence: ![BSD 3-Clause](https://github.com/co1ncidence/mountaineer.vim/blob/master/LICENSE)

# 1984-nord
![Xresources](1984-nord/.Xresources)

![Colours](1984-nord/pane.png)

Based on https://github.com/arcticicestudio/nord-visual-studio-code | Licence: ![MIT](https://github.com/arcticicestudio/nord-visual-studio-code/blob/develop/LICENSE)

# 1984-papercolour
![Xresources](1984-papercolour/.Xresources)

![Colours](1984-papercolour/pane.png)

Based on https://github.com/NLKNguyen/papercolor-theme | Licence: ![MIT](https://github.com/NLKNguyen/papercolor-theme/blob/master/LICENSE)

# 1984-rose-pine
![Xresources](1984-rose-pine/.Xresources)

![Colours](1984-rose-pine/pane.png)

Based on https://github.com/rose-pine/rose-pine-theme

# 1984-solarised
![Xresources](1984-solarised/.Xresources)

![Colours](1984-solarised/pane.png)

# 1984-stellar
![Xresources](1984-stellar/.Xresources)

![Colours](1984-stellar/pane.png)

Based on https://github.com/felix-u/stellar-theme | Licence: ![MIT](https://github.com/felix-u/stellar-theme/blob/master/LICENSE)


text:
# SIMPL3
## A simple WebGL research framework for prototyping new ideas
SIMPL3 is a super simple library designed to prototype new ideas in WebGL. It abstracts several fiddly features common to most applications, allowing the programmer to concentrate on the more interesting aspects of developing new ideas.

SIMPL3:
* is a simple boiler-plate renderer which enables you to quickly prototype ideas in WebGL
* provides an orbit camera and mouse/touchscreen controls, but nothing else
* requires the programmer to write their own rendering and shader code

Compared to three.js, it is much lower level, but also easier to prototype new ideas.

### How to use

Download the full build from the [github repository](https://github.com/AlunAlun/SIMPL3/tree/master/build).

#### Dependencies

SIMPL3 has a couple of dependencies - all are included in the full build, so you only have to source one js file.

[GL-Matrix](http://glmatrix.net/) is used to manage all matrices. This is kind of essential to use also if you want to use the built in camera and controls.

(Optional) [LiteGL](http://tamats.com/projects/litegl/) is used for basic WebGL rendering. Using LiteGL is purely optional though. SIMPL3 exposes a gl variable to access the created webgl context for you to write any WebGL code you like. Most of the examples below use LiteGL to abstract the rendering, because it's a great library.

#### Defining components
SIMPL3 defines a simple scene which contains a list of objects. For each object, it calls two methods, update() and draw(). update gets sent a delta time variable, and draw gets sent parameters representing the global model, view, and projection matrices, and a 3-component vector representing a global scene light. It is up to you to manage the draw calls and shaders.

Finally, the object must set a property called 'ready' to true.
```
function DemoComponent(){
	this.ready = true;
	this.update = function(dt) {
		//any code you want updating
	}
	this.draw = function(model, view, projection, lightPosition) {
		//all your rendering code goes here
	}
}

```

#### Initialising the scene

Once you have defined your components, you only need four/five lines of code to set up the scene:

```
//initialise everything, passing the id of a parent element
SIMPL3.init("id_of_container_element");

//set camera, (position, target)
SIMPL3.setCamera([0,0,5], [0,0,0]);

//set single global light (optional)
SIMPL3.setLight([-100, 100, 100]);

//...create component object....
var dc = new DemoComponent();

//add component to the scene
SIMPL3.objects.push(dc);

```

#### Examples

Check out the demos:
* [basic](http://alunevans.info/projects/SIMPL3/demos/basic/)
* [loading an external shader](http://alunevans.info/projects/SIMPL3/demos/external_shaders/)
* [a fully-fledged component](http://alunevans.info/projects/SIMPL3/demos/webmesh/)

###More info

SIMPL3 is licensed under the MIT license as described in the license file.

For more info contact me at [alunevans.info](http://alunevans.info) or [@alunthomasevans](https://twitter.com/alunthomasevans)


text:
# AJ.Console
Basic console functionality

See the following posts for background:
- https://ajdotnet.wordpress.com/2006/08/31/long-live-console-applications/
- https://ajdotnet.wordpress.com/2008/01/19/command-line-tool-vs-powershell-cmdlet/

Note: This solution depends on https://github.com/ajdotnet/AJ.Common.


text:
# Data Structures and Algorithms: 2010/11/15-21
1: [CAT-generation of ideals](https://doi.org/10.48550/arXiv.1011.3373)
2: [Worst case efficient single and multiple string matching in the Word-RAM  model](https://doi.org/10.48550/arXiv.1011.3441)
3: [Counting Colours in Compressed Strings](https://doi.org/10.48550/arXiv.1011.3480)
4: [Pattern Kits](https://doi.org/10.48550/arXiv.1011.3491)
5: [Program Size and Temperature in Self-Assembly](https://doi.org/10.48550/arXiv.1011.3493)
6: [Fast Multiplication of Matrices with Decay](https://doi.org/10.48550/arXiv.1011.3534)
7: [Directed Spanners via Flow-Based Linear Programs](https://doi.org/10.48550/arXiv.1011.3701)
8: [Optimal Lower Bounds for Universal and Differentially Private Steiner  Tree and TSP](https://doi.org/10.48550/arXiv.1011.3770)
9: [Magnetic Towers of Hanoi and their Optimal Solutions](https://doi.org/10.48550/arXiv.1011.3843)
10: [Non-Orthodox Combinatorial Models Based on Discordant Structures](https://doi.org/10.48550/arXiv.1011.3944)
11: [Supervised Random Walks: Predicting and Recommending Links in Social  Networks](https://doi.org/10.48550/arXiv.1011.4071)
12: [Combinatorial Geometry of Graph Partitioning - I](https://doi.org/10.48550/arXiv.1011.4401)
13: [Compressed Transmission of Route Descriptions](https://doi.org/10.48550/arXiv.1011.4465)
14: [New Algorithms on Wavelet Trees and Applications to Information  Retrieval](https://doi.org/10.48550/arXiv.1011.4532)
15: [Random Projections for $k$-means Clustering](https://doi.org/10.48550/arXiv.1011.4632)

repository: stringologytimes/StringologyTimes

repo_name: stringologytimes/StringologyTimes


text:
---
title: Including Patterns
tags:
  - docs
category: patterns
eleventyNavigation:
  title: Including Patterns
  key: patterns
  order: 90
sitemapPriority: '0.8'
sitemapChangefreq: 'monthly'
---

To include one pattern within another, for example to create a molecule from several atoms, you can either use:

- a shorthand include syntax or
- the default include syntax for the template language you're using (e.g. Mustache, Twig, Handlebars).

## The Shorthand Include Syntax

The shorthand include syntax is less verbose than the default include syntax for many template languages. The shorthand syntax uses the following format:

    [patternGroup]-[patternName]

For example, to include the following pattern in a molecule:

    atoms/images/landscape-16x9.mustache

The shorthand include syntax would be:

    atoms-landscape-16x9

The pattern type matches the top-level folder and is `atoms`. The pattern name matches the template file and is `landscape-16x9`. Any digits used in the filename for ordering (which is deprecated, use [the order parameter](/docs/reorganizing-patterns/) instead) are _dropped_ from both the pattern type and pattern name references. Pattern subgroups are _never_ a part of the shorthand include syntax. This way patterns can be re-organized within a pattern type and/or by using digits (which is deprecated, use [the order parameter](/docs/reorganizing-patterns/) instead) without needing to change your pattern includes.

The following are examples of using the shorthand include syntax with our supported PatternEngines:

```
{% raw %}{{> atoms-landscape-16x9 }}          // Mustache{% endraw %}
{% raw %}{% include "atoms-landscape-16x9" %} // Twig{% endraw %}
```

The shorthand syntax also allows for fuzzy matching on pattern names. This means that if you feel your pattern name is going to be unique within a given pattern type you can supply just the unique part of the pattern name and the partial will be included correctly. For example, using the shorthand syntax the pattern `atoms-landscape-16x9.mustache` could be written as:

    atoms-16x9

_Warning:_ Because subgroups are not included in the shorthand include syntax a given pattern name needs to be unique within its _pattern type_ and not just its pattern subgroup. If you run into this problem you can do one of two things:

- use the default include syntax for your template language or
- give your pattern a unique name and use [the pattern's documentation](/docs/documenting-patterns/) to provide the pattern name

## The Default Include Syntax

If you need more specificity when including patterns the Node version of Pattern Lab also support the include syntax for the template language that you're using. For example, the syntax for Mustache is the path to the pattern minus the `.mustache` extension. Let's say we wanted to include the following pattern in a molecule:

    atoms/images/landscape-16x9.mustache

The default Mustache include syntax would be:

```handlebars
{% raw %}{{> atoms/images/landscape-16x9 }}{% endraw %}
```

**Important:** Unlike the shorthand include syntax the template language specific include syntax **must** include any digits used for ordering (which is deprecated, use [the order parameter](/docs/reorganizing-patterns/) instead) and subgroup directories. Pattern paths need to be updated when either is changed for a given pattern.

## Examples and Gotchas

Here are some examples of how to include patterns as well as some gotchas.

```handlebars
{% raw %}// partials to match
atoms/global/test.mustache
atoms/global/test-with-picture.mustache

// using the shorthand partials syntax
{{> atoms-test }}               // will match atoms/global/test.mustache
{{> atoms-test-with-picture }}  // will match atoms/global/test-with-picture.mustache

// using the default mustache partials syntax
{{> atoms/global/test }}  // will match atoms/global/test.mustache{% endraw %}
```

repository: pattern-lab/patternlab-node

branch_name: refs/heads/dev

repo_name: pattern-lab/patternlab-node


text:
# up-framework-demo
Demo Applications Using Up! Framework

**This project requires Java 8**

There is more information on Up! [here](https://restup.github.io/up-framework/)

To run the spring boot example

```shell script
cd  up-demo-spring-boot
mvn spring-boot:run
```

repository: restup/up-framework-demo

gha_language: Java

repo_name: restup/up-framework-demo


text:
# jitsi-docker

This repository is a list of some docker compose that will work as jitsi server. All of services that own by jitsi is reformed as container in this repository. So we will using [docker-compose] to deploy this server.

It look like this repository has been supported to deploy in production. For further reading or guide to install it using docker-compose you can take a look at [quick-start readme]

## What we do with this repo
In this list we write down what change we made to this repository. We write it refering to license of this original repository. List of what we change :

* Disable P2P feature
* Enable local video recording, it will need jibri they said
* Enable recording button in top-bar

## Disclaimer
This repo is forked from [official jitsi/docker-jitsi-meet]

## License
This repository using [Apache License 2.0]

## to-do
* add some badge
* automated build and testing if possible. Because the easiest way to build docker image is using [docker automated test & build]
* write something about it on a blog maybe?

## Timeline Progress
* [25032020] this repo created
* [26032020] Update README.md and try docker-compose SUCCESS LOCALLY

[docker-compose]:https://docs.docker.com/compose/
[official jitsi/docker-jitsi-meet]:https://github.com/jitsi/docker-jitsi-meet
[quick-start readme]:https://github.com/scen-git/jitsi-docker/blob/master/SOURCE.md#quick-start
[Apache License 2.0]:https://github.com/scen-git/jitsi-docker/blob/master/LICENSE
[docker automated test & build]:https://docs.docker.com/docker-hub/builds/advanced/

repository: scen-git/jitsi-docker

repo_name: scen-git/jitsi-docker