text:
<!--- Provide a general summary of your changes in the Title above -->

## Description
<!--- Describe your changes in detail -->

## Motivation and Context
<!--- Why is this change required? What problem does it solve? -->
<!--- If it fixes an open issue, please link to the issue here. -->

## Summary of Changes for Release Notes
<!--- Brief summary of changes that could be copied to the Release Notes. -->
<!--- Skip this section if this is a maintenance PR (CI, unit tests, typo fix etc.) -->
<!--- PRs with feature changes will not be merged without this section filled. -->

<!--- Group the changes in the following sections: -->

### Fixed

### Added

### Changed

### Removed

## How Has This Been Tested?
<!--- Please describe in detail how you tested your changes. -->
<!--- Include details of your testing environment, and the tests you ran to -->
<!--- see how your change affects other areas of the code, etc. -->

<!--
## Screenshots (if appropriate):
-->

repository: scikit-beam/scikit-beam

repo_name: scikit-beam/scikit-beam


text:
# pr-diverge-reminder

> A GitHub App built with [Probot](https://github.com/probot/probot) that A probot App reminds you when the base branch changes

# Usage

There are a few assumptions to use this bot,
1. You use Github pull request in your workflow.
2. You prefer linear git history when incorporating the feature branch
3. To accomplish step 2, you always use `git rebase` to update your pull request.

If you sometimes forget to update your pull request before merging, this bot is perfect reminder for you,
it pings the author of the pull request when there are changes in the base branch, see the following snapshot:

<img src="https://raw.githubusercontent.com/xavierchow/asset/master/pr-diverge-reminder/usage.png" width="650">

## Setup

```sh
# Install dependencies
npm install

# Run the bot
npm start
```

## Contributing

If you have suggestions for how pr-base-reminder could be improved, or want to report a bug, open an issue! We'd love all and any contributions.

For more, check out the [Contributing Guide](CONTRIBUTING.md).

## Big Thanks
[Xincen](https://github.com/chiyokei) to provide the icon for this bot.

## License

[ISC](LICENSE) © 2020 Xavier Zhou<EMAIL_ADDRESS>

license: ISC

repository: xavierchow/pr-diverge-reminder

branch_name: refs/heads/master

extension: md

gha_language: JavaScript

gha_license_id: ISC

license_type: permissive

repo_name: xavierchow/pr-diverge-reminder


text:
---
title: 'January Sales Contest Names'
og_title: 'January Sales Contest Names'
description: A list of creative and motivating sales contest names for January
og_description: A list of creative and motivating sales contest names for January
categories: ["ACM"]
id: 221
author:
  name: SmartWinnr
  email<EMAIL_ADDRESS>weight: -221
slug: "january-sales-contest-names"
featured_image: "/images/blog-221/image1.jpg"
isFeatured: false
date: '2022-01-07T07:30:32+08:00'
tags: ["Sales", "Sales Contest"]
relatedBlogs : ["How to Launch a Sales Contest",
"25 Creative Sales Team Names",
"Sales Contest Communication Template",
"Top 20 Sales Contest Names",
"23 Sales incentive ideas to keep your sales team motivated"
]

---

10, 9, 8, 7, 6, 5, 4, 3, 2, 1– **Happy New Year!**

We have turned another last page of a year on the calendar and entered a new year. In this new year, I’m sure you have,

* New hopes for your business
* New sales targets for your team to achieve
* And new opportunities which they should pursue

But at a time when most of your employees are freshly coming out of vacation mode, how can you ensure that they don’t waste the crucial first few weeks of the year?

One best way is to gamify the sales activities for your team. [ Check out this blog ](https://www.smartwinnr.com/post/7-sales-contest-ideas-for-january/) to get some good January sales contest ideas.

In this blog, we are going to focus on some motivating and inspiring names that you can give to your January sales contests

\
\

**1. New Year, New Goals:** Hit the refresh button and assign new goals/ targets that your sales reps need to achieve in the first month of the year. The rep who first meets his target will be declared a winner and rewarded with exciting prizes.

**2. Out with the old:** Organize this contest and encourage your reps to clear the CRM of all the older and dead contacts.

**3. Ringing in the new year:** Organize this contest and encourage your reps to call up prospective customers and fill the sales pipeline with new leads.

**4. Own the first 30:** This contest is to encourage your sales reps to bring in as much sales as they can in the first month of the year.

**5. Republic Day Rush:** This contest can be organized for your Indian sales team on the 26th of January (Republic Day) to encourage them to progress as many leads as they can along the sales pipeline.

**6. New Years’ resolutions:** Organize this as an annual sales contest that runs throughout the year. Ask your sales reps to set a professional goal for themselves for this year. It could be

To beat their own past performance record

To beat their peer’s performance

To beat the performance of a top performer in their team

Or to improve a specific sales skill

Once they decide on a goal and communicate it with you, help them to achieve that goal through regular coaching and rewarding them every time they make a progress.

**7. New Year’s Rush:**  If you have launched some new product(s) in the new year then run this contest to get your reps to promote the sales of your newly launched product.

**8. New Year’s Bonus:** Run this contest and encourage your reps to upsell and earn a bonus.

**9. Happy Beginning:** Run this contest in the first quarter of the year and encourage your reps to give a happy beginning to the year by making the highest amount of quarterly sales.

**10. Prosperous First Month:**  Organize this contest in the first month of the year and encourage your reps to make this first month prosperous by closing a maximum number of deals. Reps compete with each other in closing more number of deals. At the end of the first month, reward the person who closes more deals than his peers.

**11. January Jackpot:**  Focus this contest around getting your sales reps to progress stalled contacts along the sales pipeline. The person who progresses more number of contacts wins a jackpot prize.

**12. Crazy instant wins:** Organize this contest and encourage your sales reps to bring in as many referrals as they can from the existing customers. Give instant exciting prizes (like Amazon gift cards or chocolates) to people for each referral they bring in.

**13. January Olympics:** Organize this contest between your sales teams operating in various territories. Encourage those teams to compete with each other in bringing in the highest amount of the first month’s sales profit. The team that succeeds in bringing the highest amount of sales profit, wins the contest.

\
\

### **Looking for sales contest ideas for different months? Check out this below:**

\

January– [7 Sales Contest Ideas for January](https://www.smartwinnr.com/post/7-sales-contest-ideas-for-january/)

\

February– [7 Sales Contest Ideas for February](https://www.smartwinnr.com/post/7-sales-contest-ideas-for-february/)

\

March– [ 8 Sales Contest Ideas for March](https://www.smartwinnr.com/post/8-sales-contest-ideas-for-march/)

\

April– [7 Sales Contest Ideas for April](https://www.smartwinnr.com/post/7-sales-contest-ideas-for-april/)

\

May– [8 Sales Contest Ideas for May](https://www.smartwinnr.com/post/8-sales-contest-ideas-for-may/)

\

June– [8 Sales Contest Ideas for June](https://www.smartwinnr.com/post/8-sales-contest-ideas-for-june/)

\

July– [8 Sales Contest Ideas for July](https://www.smartwinnr.com/post/8-sales-contest-ideas-for-july-2023/)

\

August– [7 Sales Contest Ideas for August](https://www.smartwinnr.com/post/7-sales-contest-ideas-for-august/)

\

September– [8 Sales Contest Ideas for September](https://www.smartwinnr.com/post/8-sales-contest-ideas-for-september/)

\

October– [8 Sales Contests For October](https://smartwinnr.com/post/8-sales-contests-for-october/)

\

November– [8 Sales Contests for November](https://smartwinnr.com/post/8-sales-contests-for-november/)

\

December– [7 fun sales contests for December](https://smartwinnr.com/post/7-fun-sales-contests-for-december/)

\
\

### **Looking for Seasonal Sales Contest Ideas?**

[5 Sales Contest for Summer](https://smartwinnr.com/post/5-sales-contest-for-summer/)

[5 Sales Contests for Winter](https://smartwinnr.com/post/sales-contests-for-winter/)

[7 Fun Sales Contest Ideas to Motivate your Team for Thanksgiving and Black Friday](https://www.smartwinnr.com/post/7-fun-sales-contest-ideas-to-motivate-your-team-for-thanksgiving-and-black-friday/)

\
\

### **Want to give cool and creative names for your sales contests? Get naming ideas from this blog below:**

[Top 20 Sales Contest Names](https://www.smartwinnr.com/post/top-20-sales-contest-names/)

\
\

### **Want to give creative and funny names for your sales team? Get ideas from these articles below:**

[25 Creative Sales Team Names](https://www.smartwinnr.com/post/25-creative-sales-team-names/)

[34 Funny Sales Team Names](https://www.smartwinnr.com/post/funny-sales-team-names/)

\
\

### **How will you communicate the contests that you organize to your participants?**

Once you have a perfect contest idea and a suitable name for it, focus on communicating it effectively to your participants. Follow our [sales contest communication template](https://www.smartwinnr.com/post/sales-contest-communication-template/) to announce your contest.

\
\

### **Looking for award names and prizing ideas to give out to your contest winners? Read these articles below:**

[Creative employee recognition awards.](https://www.smartwinnr.com/post/creative-employee-recognition-award-names/)

[23 Sales incentive ideas to keep your sales team motivated](https://www.smartwinnr.com/post/sales-incentive-ideas-to-keep-your-sales-team-motivated/)

license: MIT

repository: smartwinnr/site-smartwinnr

gha_language: CSS

gha_license_id: MIT

repo_name: smartwinnr/site-smartwinnr


text:
# leetcode
Solutions to [LeetCode](https://leetcode.com/problemset/all/) problems.

#### Content
```
5. Longest Palindromic Substring
7. Reverse Integer
9. Palindrome Number
13. Roman to Integer
14. Longest Common Prefix
19. Remove Nth Node From End of List
21. Merge Two Sorted Lists
26. Remove Duplicates from Sorted Array
27. Remove Element
35. Search Insert Position
38. Count and Say
49. Group Anagrams
53. Maximum Subarray
54. Spiral Matrix
66. Plus One
88. Merge Sorted Array
100. Same Tree
101. Symmetric Tree
107. Binary Tree Level Order Traversal II
110. Balanced Binary Tree
111. Minimum Depth of Binary Tree
112. Path Sum
118. Pascal's Triangle
119. Pascal's Triangle II
125. Valid Palindrome
136. Single Number
141. Linked List Cycle
160. Intersection of Two Linked Lists
167. Two Sum II - Input array is sorted
168. Excel Sheet Column Title
169. Majority Element
171. Excel Sheet Column Number
172. Factorial Trailing Zeroes
175. Combine Two Tables
176. Second Highest Salary
181. Employees Earning More Than Their Managers
182. Duplicate Emails
183. Customers Who Never Order
189. Rotate Array
190. Reverse Bits
191. Number of 1 Bits
193. Valid Phone Numbers
195. Tenth Line
196. Delete Duplicate Emails
197. Rising Temperature
198. House Robber
202. Happy Number
203. Remove Linked List Elements
204. Count Primes
206. Reverse Linked List
207. Course Schedule
208. Implement Trie (Prefix Tree)
211. Add and Search Word - Data structure design
213. House Robber II
217. Contains Duplicate
219. Contains Duplicate II
225. Implement Stack using Queues
226. Invert Binary Tree
231. Power of Two
232. Implement Queue using Stacks
234. Palindrome Linked List
235. Lowest Common Ancestor of a Binary Search Tree
246. Strobogrammatic Number
257. Binary Tree Paths
263. Ugly Number
270. Closest Binary Search Tree Value
278. First Bad Version
283. Move Zeroes
290. Word Pattern
293. Flip Game
303. Range Sum Query - Immutable
307. Range Sum Query - Mutable
326. Power of Three (or any other base)
342. Power of Four
344. Reverse String
345. Reverse Vowels of a String
347. Top K Frequent Elements
349. Intersection of Two Arrays
350. Intersection of Two Arrays II
367. Valid Perfect Square
371. Sum of Two Integers
374. Guess Number Higher or Lower
383. Ransom Note
387. First Unique Character in a String
389. Find the Difference
400. Nth Digit
401. Binary Watch
402. Remove K Digits
404. Sum of Left Leaves
405. Convert a Number to Hexadecimal
409. Longest Palindrome
414. Third Maximum Number
415. Add Strings
427. Construct Quad Tree
429. N-ary Tree Level Order Traversal
434. Number of Segments in a String
437. Path Sum III
441. Arranging Coins
443. String Compression
447. Number of Boomerangs
448. Find All Numbers Disappeared in an Array
453. Minimum Moves to Equal Array Elements
455. Assign Cookies
459. Repeated Substring Pattern
461. Hamming Distance
475. Heaters
476. Number Complement
482. License Key Formatting
485. Max Consecutive Ones
492. Construct the Rectangle
496. Next Greater Element I
500. Keyboard Row
501. Find Mode in Binary Search Tree
504. Base 7
506. Relative Ranks
507. Perfect Number
509. Fibonacci Number
520. Detect Capital
521. Longest Uncommon Subsequence I
530. Minimum Absolute Difference in BST (same as 738)
532. K-diff Pairs in an Array
538. Convert BST to Greater Tree
541. Reverse String II
543. Diameter of Binary Tree
551. Student Attendance Record I
557. Reverse Words in a String III
558. Quad Tree Intersection
559. Maximum Depth of N-ary Tree
561. Array Partition I
563. Binary Tree Tilt
566. Reshape the Matrix
572. Subtree of Another Tree
575. Distribute Candies
581. Shortest Unsorted Continuous Subarray
589. N-ary Tree Preorder Traversal
590. N-ary Tree Postorder Traversal
595. Big Countries
643. Maximum Average Subarray I
653. Two Sum IV - Input is a BST
662. Maximum Width of Binary Tree
697. Degree of an Array
709. To Lower Case
729. My Calendar I
734. Sentence Similarity
743. Network Delay Time
747. Largest Number At Least Twice of Others
755. Pour Water
758. Bold Words in String
766. Toeplitz Matrix
783. Minimum Distance Between BST Nodes
788. Rotated Digits
800. Similar RGB Color
812. Largest Triangle Area
832. Flipping an Image
844. Backspace String Compare
876. Middle of the Linked List
895. Maximum Frequency Stack
905. Sort Array By Parity
938. Range Sum of BST
977. Squares of a Sorted Array
989. Add to Array-Form of Integer
1021. Remove Outermost Parentheses
1108. Defanging an IP Address
1114. Print in Order
1115. Print FooBar Alternately
1116. Print Zero Even Odd
1117. Building H2O
```

repository: mpanibrat/leetcode

repo_name: mpanibrat/leetcode


text:
But, you should give each child at most one cookie.

> Each child `i` has a greed factor `g[i]`, which is the minimum size of a cookie that the child will be content with; and each cookie `j` has a size `s[j]`. If `s[j] >= g[i]`, we can assign the cookie `j` to the child i, and the child `i` will be content. Your goal is to maximize the number of your content children and output the maximum number.

## Ideas

It's kind of straightforward with greedy algorithm. We always want to feed the child with smallest greedy factor by choosing the cookie with smallest possible size.

We use 2 heaps to keep children & cookies in memory for quickly fetching child or cookie with smallest greedy factor/size. So the extra memory space is `O(|g| + |s|)`.

Analysing the time complexity, data copy and heapify take time `O(|g| + |s|)`. For coming up the way to distribute the cookies, the running time is `O(log(|g|))+O(log(|g-1|))+...+O(log1)+O(log(|s|))+O(log(|s-1|))+...+O(log1)`. To simplify,

So the total running time would be `O(log|g| + log|s|)`.

## Solution

```py
import heapq

class Solution:
    def findContentChildren(self, g: List[int], s: List[int]) -> int:
        greedy = g[:]
        size = s[:]
        heapq.heapify(greedy)
        heapq.heapify(size)

        children_fed = 0
        while len(greedy) > 0 and len(size) > 0:
            while len(size) > 0 and size[0] < greedy[0]:
                heapq.heappop(size)
            if len(size) > 0:
                children_fed += 1
                heapq.heappop(greedy)
                heapq.heappop(size)

        return  children_fed
```

repository: MarcosQiu/my-docs

branch_name: refs/heads/main

filename: 455. Assign Cookies.md

repo_name: MarcosQiu/my-docs


text:
# Pixel-Art-Maker

Pixel Art Maker is a simple App? that draws a grid on a page and allows you to fill each cell with a color.

![Pixel Art Maker Screenshot](https://github.com/oguching/Pixel-Art-Maker/blob/master/space_invaders_alc.png
"Pixel Art Maker Screenshot")

repository: oguching/Pixel-Art-Maker

repo_name: oguching/Pixel-Art-Maker


text:
<!--
    Copyright 2013-2014 The GLFW-RS Developers. For a full listing of the authors,
    refer to the AUTHORS file at the top-level directory of this distribution.

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

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

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

# glfw-rs

[![Crates.io](https://img.shields.io/crates/v/glfw)](https://crates.io/crates/glfw)
[![Docs.rs](https://docs.rs/glfw/badge.svg)](https://docs.rs/glfw)
[![Build Status](https://travis-ci.org/PistonDevelopers/glfw-rs.svg?branch=master)](https://travis-ci.org/PistonDevelopers/glfw-rs)

GLFW bindings and wrapper for The Rust Programming Language.

## Example

~~~rust
extern crate glfw;

use glfw::{Action, Context, Key};

fn main() {
    let mut glfw = glfw::init(glfw::FAIL_ON_ERRORS).unwrap();

    let (mut window, events) = glfw.create_window(300, 300, "Hello this is window", glfw::WindowMode::Windowed)
        .expect("Failed to create GLFW window.");

    window.set_key_polling(true);
    window.make_current();

    while !window.should_close() {
        glfw.poll_events();
        for (_, event) in glfw::flush_messages(&events) {
            handle_window_event(&mut window, event);
        }
    }
}

fn handle_window_event(window: &mut glfw::Window, event: glfw::WindowEvent) {
    match event {
        glfw::WindowEvent::Key(Key::Escape, _, Action::Press, _) => {
            window.set_should_close(true)
        }
        _ => {}
    }
}
~~~

## Using glfw-rs

### Prerequisites

Make sure you have [compiled and installed GLFW 3.x](http://www.glfw.org/docs/latest/compile.html).
You might be able to find it on your package manager, for example on OS X:
`brew install glfw3` (you may need to run `brew tap homebrew/versions`).
If not you can download and build the library
[from the source](http://www.glfw.org/docs/latest/compile.html) supplied on the
GLFW website. Note that if you compile GLFW with CMake on Linux, you will have
to supply the `-DCMAKE_C_FLAGS=-fPIC` argument. You may install GLFW to your
`PATH`, otherwise you will have to specify the directory containing the library
binaries when you call `make` or `make lib`:

~~~
GLFW_LIB_DIR=path/to/glfw/lib/directory make
~~~

### Including glfw-rs in your project

Add this to your `Cargo.toml`:

~~~toml
[dependencies.glfw]
version = "*"
~~~

#### On Windows

By default, `glfw-rs` will try to compile the `glfw` library. If you want to link to your custom
build of `glfw` or if the build doesn't work (which is probably the case on Windows), you can
disable this:

~~~toml
[dependencies.glfw]
version = "*"
default-features = false
~~~

## Support

Contact `bjz` on irc.mozilla.org [#rust](http://mibbit.com/?server=irc.mozilla.org&channel=%23rust)
and [#rust-gamedev](http://mibbit.com/?server=irc.mozilla.org&channel=%23rust-gamedev),
or [post an issue](https://github.com/bjz/glfw-rs/issues/new) on GitHub.

## glfw-rs in use

- [sebcrozet/kiss3d](https://github.com/sebcrozet/kiss3d)
- [Jeaye/q3](https://github.com/Jeaye/q3)
- [cyndis/rsmc](https://github.com/cyndis/rsmc/)
- [ozkriff/zoc](https://github.com/ozkriff/zoc)

repository: PistonDevelopers/glfw-rs

gha_language: Rust

repo_name: PistonDevelopers/glfw-rs


text:
Chapter 17 - cluster-quartz2
----------------------------

This directory holds an example how to use Quartz Scheduler to trigger routes to be
running within certain time windows in a master/slave mode.

### 17.6.1 Clustered scheduling using Quartz

#### Preparing database

This example requires a shared database (we are using Postgres) which you can run using Docker

    docker run -p 5432:5432 -e POSTGRES_USER=quartz -e POSTGRES_PASSWORD=quartz -d postgres

Then you need to initialize the database by running a script which you can run from Java with:

    mvn compile exec:java -P init

The SQL script to initialize the Postgres database is located in the `tables_postgres.sql` file.
You can find SQL scripts for other databases that Quartz supports if you download Quartz from
its website (http://www.quartz-scheduler.org/) and unzip the download and look in the
`doc/dbTables` directory.

#### Running Camel

When the database is up and running its ready to accept connections on port 5432 and because
we have networked Docker then we can access on `localhost`.

The example requires to run at two JVMs concurrently by starting each Maven goal from each terminal:

    mvn compile exec:java -Pfoo
    mvn compile exec:java -Pbar

You can then see that every minute the cron job is triggered and because its clustered, then its
 only one of the two Camel instances that runs the job. Quartz will run the job on the first node that
 grabs the lock from the database happens by random.

You can stop either instance of the running Camel and the running node will ensure to run the job.

For example here Foo runs the first two times, and the Bar runs the third time. Followed by Foo and Bar.
Only one node runs the job at every minute.

```
2017-02-26 18:27:00,036 [amel-1_Worker-2] INFO  route1                         - Foo running at Sun Feb 26 18:27:00 CET 2017
2017-02-26 18:28:00,039 [amel-1_Worker-3] INFO  route1                         - Foo running at Sun Feb 26 18:28:00 CET 2017
2017-02-26 18:29:00,053 [amel-1_Worker-1] INFO  route1                         - Bar running at Sun Feb 26 18:29:00 CET 2017
2017-02-26 18:30:00,039 [amel-1_Worker-1] INFO  route1                         - Foo running at Sun Feb 26 18:30:00 CET 2017
2017-02-26 18:31:00,048 [amel-1_Worker-2] INFO  route1                         - Bar running at Sun Feb 26 18:31:00 CET 2017
```

If you stop one of the nodes then the existing running node will run the job. And when the other node comes back online
then they are both able to run the jobs again.

### Looking in the database

You can use a database query tool (IDEA has built-in database browser) which you can use to connect
to the database on

     jdbc:postgresql://localhost:5432/quartz

  with username: `quartz` and password: `quartz`.

Then you can browse the quartz tables and see what date it contains which holds the state of the
clustered quartz scheduler.

gha_language: Java


text:
#What is Wikispeedia Network?
Wikispeedia Network is a web application that allows to visualize and interact with network
data corresponding to navigation paths on Wikipedia, collected through the human-computation game Wikispeedia. Just look for a
word and see!

#Data sources
For this project I've used the dataset available at [SNAP webpage](http://snap.stanford.edu/data/wikispeedia.html)

In [Wikispeedia] (http://cs.mcgill.ca/~rwest/wikispeedia/), users are asked to navigate from a given source to a given target article, by only clicking Wikipedia links.
I have transformed the dataset in two JSON files with the edges and nodes of the network. The original dataset contains a condensed
version of Wikipedia (4,604 articles).

![Wikispeedia Network](https://cloud.githubusercontent.com/assets/9200682/17309105/78024860-583d-11e6-811a-174f6d0da888.png)

#Demo
You can play a demo in my [personal webpage] (http://fjlozano.me/projects/wikispeedia-network/)

repository: franloza/Wikispeedia-Network

repo_name: franloza/Wikispeedia-Network


text:
# Elixir Training Challenge

From [RocketSeat](https://rocketseat.com.br)/Ignite01.

The challenging proposed is count the odd numbers from a list of strings.

Reference: Chapter I - Module 1 - Challenge 2
Link: <https://www.notion.so/Desafio-02-Filtragem-em-listas-87cf8190c3594fe59b2486c5b7df180c>


text:
---
layout: doc_page
---
# JavaScript Programming Guide

This page discusses how to use JavaScript to extend Druid.

## Examples

JavaScript can be used to extend Druid in a variety of ways:

- [Aggregators](../querying/aggregations.html#javascript-aggregator)
- [Extraction functions](../querying/dimensionspecs.html#javascript-extraction-function)
- [Filters](../querying/filters.html#javascript-filter)
- [Post-aggregators](../querying/post-aggregations.html#javascript-post-aggregator)
- [Input parsers](../ingestion/data-formats.html#javascript)
- [Router strategy](../development/router.html#javascript)
- [Worker select strategy](../configuration/indexing-service.html#javascript)

JavaScript can be injected dynamically at runtime, making it convenient to rapidly prototype new functionality
without needing to write and deploy Druid extensions.

Druid uses the Mozilla Rhino engine at optimization level 9 to compile and execute JavaScript.

## Security

Druid does not execute JavaScript functions in a sandbox, so they have full access to the machine. So Javascript
functions allow users to execute arbitrary code inside druid process. So, by default, Javascript is disabled.
However, on dev/staging environments or secured production environments you can enable those by setting
the [configuration property](../configuration/index.html)
`druid.javascript.enabled = true`.

## Global variables

Avoid using global variables. Druid may share the global scope between multiple threads, which can lead to
unpredictable results if global variables are used.

## Performance

Simple JavaScript functions typically have a slight performance penalty to native speed. More complex JavaScript
functions can have steeper performance penalties. Druid compiles JavaScript functions once per node per query.

You may need to pay special attention to garbage collection when making heavy use of JavaScript functions, especially
garbage collection of the compiled classes themselves. Be sure to use a garbage collector configuration that supports
timely collection of unused classes (this is generally easier on JDK8 with the Metaspace than it is on JDK7).

## JavaScript vs. Native Extensions

Generally we recommend using JavaScript when security is not an issue, and when speed of development is more important
than performance or memory use. If security is an issue, or if performance and memory use are of the utmost importance,
we recommend developing a native Druid extension.

In addition, native Druid extensions are more flexible than JavaScript functions. There are some kinds of extensions
(like sketches) that must be written as native Druid extensions due to their need for custom data formats.

repository: metamx/druid

repo_name: metamx/druid


text:
crypto-sandbox
====

It looks like this is going to be where I gain a toe hold on implementing cryptography.

Paillier cryptosystem
----

```haskell
{-# LANGUAGE RecordWildCards #-}

import Sandbox.Paillier

main :: IO ()
main = newKeyPair 128 >>= \(sk, pk) ->
  withPaillier pk $ \PaillierKit{..} -> do
    let msg1 = 12345
        msg2 = 67890

    -- Encryption
    e1 <- encrypt msg1
    e2 <- encrypt msg2
    print e1

    -- Decryption
    print $ decrypt sk e1

    -- Additive homomorphism
    let e3 = e1 `add` e2
    print $ msg1 + msg2
    print $ decrypt sk e3

    -- Scalar multiplication
    let e4 = 21 `scale` e2
    print $ 21 * msg2
    print $ decrypt sk e4
```

Discreet log contracts
----

[Discreet log contracts][dcl] is a system by which an "oracle" can sign one of
many messages and other users can use this signature to unlock transaction
outputs.  See `example` in `src/Sandbox/DiscreetLogContracts.hs` for a worked
discreet log contract flow.

[dcl]: https://adiabat.github.io/dlc.pdf

repository: GambolingPangolin/crypto-sandbox

repo_name: GambolingPangolin/crypto-sandbox


text:
# Get Date Filtered Records

**URL** : `/v7/record/filtered`

**Status** : DONE

To get one specific plan using the plan id

**Method** : `GET`

**Auth required** : YES

**Permissions required** : `Every one who is logged in`

**Data constraints**
url-encoded data

` country=<country> `

json-encoded data

``` urlencode
start_date = <date string>&end_date = <date string>

```

## Success Responses

**Condition** : If the plan with the requested id exists .

**Code** : `200`

**Response Content**

```json
[
<Responses data >
]
```

## Error Response

**Condition** : If something unknown happened and the database returns an error .

**Code** : `500 INTERNAL SERVER ERROR`

## Notes
- There is no validation of the responses before they are sent to the client.

repository: disarm-dev/douma-api

repo_name: disarm-dev/douma-api


text:
# Selenium-Web-Driver-Manager-Example

This is a sample project, implemented using Web Driver Manager which allows to automate the management of the binary drivers (Ex: geckodriver, chromedriver, phantomdriver & etc) required by selenium web driver.

### Introdution

Previously to run automation scripts in different browsers using selenium web drivers we have to manually download the driver which is compatible with the browser version of your computer.
And have to set the path for the driver as below:

```
System.setProperty("webdriver.chrome.driver", "/path/to/binary/chromedriver");
System.setProperty("webdriver.gecko.driver", "/path/to/binary/geckodriver");
System.setProperty("webdriver.opera.driver", "/path/to/binary/operadriver");
System.setProperty("phantomjs.binary.path", "/path/to/binary/phantomjs");
System.setProperty("webdriver.edge.driver", "C:/path/to/binary/msedgedriver.exe");
System.setProperty("webdriver.ie.driver", "C:/path/to/binary/IEDriverServer.exe");
```

This is quite annoying since it forces you to link directly this binary file into your source code. In addition, you have to check manually when new versions of the binaries are released. Also when the browser get updated time to time additionally we have to download exact driver version and set the path in oder to run the scripts.

This is where WebDriverManager comes into the picture, performing in an automated way to do this dirty processes for you.

WebDriverManager is open source, released under the terms of [Apache 2.0 License.](http://www.apache.org/licenses/LICENSE-2.0)

### WebDriverManager Java Dependencies

1. You can download the WebDriverManager JAR file from here manually.
[Download WebDriverManager.](https://mvnrepository.com/artifact/io.github.bonigarcia/webdrivermanager)

2. Inorder to use the WebDriverManager for tests in a Maven project you can use the following dependency in your `pom.xml`.

```
<dependency>
    <groupId>io.github.bonigarcia</groupId>
    <artifactId>webdrivermanager</artifactId>
    <version>3.7.1</version>
    <scope>test</scope>
</dependency>
```
3. In Gradle Project use as below

```
dependencies {
    testCompile("io.github.bonigarcia:webdrivermanager:3.7.1")
}
```

### Uses of WebDriverManager

Simply using `WebDriverManager.<DriverType>.setup();` WebDriverManager do the following for you.

* It checks the version of the browser which is installed in your machine. (Ex: Chrome, Firefox).
* It checks the version of the driver (Ex: chromeDriver, geckoDriver). If the version is unknown it will use the latest version of the driver.
* It downloads the WebDriver binary if it is not present on the WebDriverManager cache `(~/.m2/repository/webdriver by default)`. It exports the proper WebDriver Java enviorment variables required by Selenium.
* WebDriverManager resolves the driver binaries for the browsers Chrome, Firefox, Opera & etc. For that, it provides several drivers managers for these browsers. These drivers managers can be used as below.

```
WebDriverManager.chromedriver().setup();
WebDriverManager.firefoxdriver().setup();
WebDriverManager.operadriver().setup();
```

### Required JAR files for run these automation scripts using Selenuim & WebDriverManager

- client-combined.jar
- byte-buddy.jar
- commons-exec.jar
- guava-jre.jar
- okhttp.jar
- okio.jar
- webdrivermanager.jar
- httpclient.jar
- httpcore.jar
- slf4j-api.jar
- slf4j-simple.jar
- commons-lang3.jar
- commons-logging.jar
- commons-io.jar

Some of these JAR files can be get, ones you download the selenium web driver.

### Exceptions can be occur and how to solve it

* **Exception in thread "main" java.lang.NoClassDefFoundError: org/apache/http/client/methods/HttpRequestBase**

If this kind of exception occurs you have to add the following dependencies for the project
  1. httpclient
  2. httpcore

* **Exception in thread "main" java.lang.NoClassDefFoundError: org/slf4j/LoggerFactory**

If this kind of exception occurs you have to add the following dependencies for the project
  1. slf4j-api
  2. slf4j-simple

* **Exception in thread "main" java.lang.NoClassDefFoundError: org/apache/commons/lang3/SystemUtils**

If this kind of exception occurs you have to add the following dependencies for the project
  1. commons-lang3

* **Exception in thread "main" java.lang.NoClassDefFoundError: org/apache/commons/logging/LogFactory**

If this kind of exception occurs you have to add the following dependencies for the project
  1. commons-logging

* **Exception in thread "main" java.lang.NoClassDefFoundError: org/apache/commons/io/IOUtils**

If this kind of exception occurs you have to add the following dependencies for the project
  1. commoins-io

## For more information you can go through the following reference.
[Automatic management of Selenium WebDriver binaries](https://github.com/bonigarcia/webdrivermanager#table-of-contents)


text:
# Changelog

## 📦 Version [v1.2.5](https://github.com/BioDWH2/BioDWH2-Neo4j-Server/releases/tag/v1.2.5)

Released: 04.08.2021

 * ```[feature]``` BioDWH2 graph is now opened read-only during creation
 * ```[chore]``` Update dependencies

## 📦 Version [v1.2.4](https://github.com/BioDWH2/BioDWH2-Neo4j-Server/releases/tag/v1.2.4)

Released: 30.06.2021

 * ```[feature]``` Create all node indices in neo4j from graph
 * ```[chore]``` Update dependencies

## 📦 Version [v1.2.3](https://github.com/BioDWH2/BioDWH2-Neo4j-Server/releases/tag/v1.2.3)

Released: 25.06.2021

 * ```[feature]``` Reuse core BioDWH2Updater
 * ```[chore]``` Update dependencies

## 📦 Version [v1.2.2](https://github.com/BioDWH2/BioDWH2-Neo4j-Server/releases/tag/v1.2.2)

Released: 16.06.2021

 * ```[chore]``` Update dependencies

 > This is a breaking change release due to the new BioDWH2 core version v0.3.5. Only workspaces created with BioDWH2 v0.3.5 or later work with this version.

---

## 📦 Version [v1.2.1](https://github.com/BioDWH2/BioDWH2-Neo4j-Server/releases/tag/v1.2.1)

Released: 10.06.2021

 * ```[fix]``` Neo4j database service now properly shuts down after ```--create``` command
 * ```[fix]``` The APOC plugin is now loaded internally without using Neo4j plugin_dir configuration to prevent other jars in the same folder from being loaded
 * ```[chore]``` Update dependencies

---

## 📦 Version [v1.2.0](https://github.com/BioDWH2/BioDWH2-Neo4j-Server/releases/tag/v1.2.0)

Released: 01.03.2021

 * ```[fix]``` Neo4j browser download is now working again
 * ```[chore]``` Update dependencies

---

## 📦 Version [v1.1.8](https://github.com/BioDWH2/BioDWH2-Neo4j-Server/releases/tag/v1.1.8)

Released: 24.01.2021

 * ```[chore]``` Update dependencies

---

## 📦 Version [v1.1.7](https://github.com/BioDWH2/BioDWH2-Neo4j-Server/releases/tag/v1.1.7)

Released: 15.12.2020

 * ```[fix]``` Object arrays of unknown type are now mapped to string arrays
 * ```[chore]``` Update dependencies

---

## 📦 Version [v1.1.6](https://github.com/BioDWH2/BioDWH2-Neo4j-Server/releases/tag/v1.1.6)

Released: 20.11.2020

 * ```[feature]``` Check for newer BioDWH2-Neo4j-Server versions
 * ```[fix]``` Collection properties are now converted to arrays

---

## 📦 Version [v1.1.5](https://github.com/BioDWH2/BioDWH2-Neo4j-Server/releases/tag/v1.1.5)

Released: 18.11.2020

 * ```[fix]``` Fix github deployment action

---

## 📦 Version [v1.1.4](https://github.com/BioDWH2/BioDWH2-Neo4j-Server/releases/tag/v1.1.4)

Released: 18.11.2020

 * ```[fix]``` Ignore properties with null values

---

## 📦 Version [v1.1.3](https://github.com/BioDWH2/BioDWH2-Neo4j-Server/releases/tag/v1.1.3)

Released: 13.11.2020

 * ```[feature]``` Database hashing is now much faster
 * ```[fix]``` Fix release packaging with service resources

---

## 📦 Version [v1.1.2](https://github.com/BioDWH2/BioDWH2-Neo4j-Server/releases/tag/v1.1.2)

Released: 10.11.2020

 * ```[feature]``` Nodes and edges are now created in transaction batches

---

## 📦 Version [v1.1.1](https://github.com/BioDWH2/BioDWH2-Neo4j-Server/releases/tag/v1.1.1)

Released: 04.11.2020

 * ```[fix]``` Ignore neo4j dependencies for dependabot due to 3.5 vs. 4.x versioning

---

## 📦 Version [v1.1](https://github.com/BioDWH2/BioDWH2-Neo4j-Server/releases/tag/v1.1)

Released: 04.11.2020

 * ```[feature]``` Check if the BioDWH2 database has changed and notify user to regenerate the Neo4j database
 * ```[feature]``` Add APOC plugin dependency
 * ```[feature]``` Add combined ```--create-start``` command
 * ```[chore]``` Update dependencies

---

## 📦 Version [v1.0](https://github.com/BioDWH2/BioDWH2-Neo4j-Server/releases/tag/v1.0)

Released: 08.10.2020


text:
# Title

SQL Employee Manager

# URL

https://github.com/atn362/SQL_employee_management.git

# Description

This application creates a database in which to sort employees by their job titles and their departments.

# Table of Contents
* [Video](#video)
* [Images](#Images)
* [Installation](#installation)
* [Usage](#usage)
* [License](#license)
* [Contribution](#contribution)
* [Tests](#tests)
* [Questions](#questions)

# Video
Video of the demonstration

Google Drive Video:
https://drive.google.com/file/d/1rZSK4IAE0DTP8py6T5LD329iOLmGx5GO/preview

YouTube Video:
https://www.youtube.com/watch?v=MVcxPdbm-gI

# Images

![code](https://user-images.githubusercontent.com/77468756/116941281-04e08800-ac35-11eb-83be-5f8aaf413eb4.png)
![employee manager](https://user-images.githubusercontent.com/77468756/116941287-06aa4b80-ac35-11eb-8467-6e10b2abd771.png)

# Installation
What is needed to install this application? Installation begins with the "Node Index" command that is typed in the integrated terminal of the index.js files

# Usage
In order to use this app, run the app in the: It is utilized in the command prompt of vscode in my case.

# License
Which license have you chosen for this project? Licensed under the MIT badge/link.
![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)
[License: MIT](https://opensource.org/licenses/MIT)

# Contribution
Who was involved in contributing to this project? Just Myself

# Tests
The following is needed to run the test: No tests were conducted when created this application

# Questions
If you have any questions about the repo, open an issue or contact my git hub account at "www.github.com/atn362" or  directly at<EMAIL_ADDRESS>


text:
# Xiaomi Mi and Aqara Air Conditioning Companion

This is a custom component for home assistant to integrate the Xiaomi Mi and Aqara Air Conditioning Companion (KTBL01LM, KTBL02LM).

Please follow the instructions on [Retrieving the Access Token](https://home-assistant.io/components/xiaomi/#retrieving-the-access-token) to get the API token to use in the configuration.yaml file.

Credits: Thanks to [Rytilahti](https://github.com/rytilahti/python-miio) for all the work.

## Features
* Power (on, off)
* Operation Mode (Heat, Cool, Auto, Dehumidify, Ventilate)
* Fan Speed (Low, Medium, High, Auto)
* Swing Mode (On, Off)
* Target Temperature
* Attributes
  - ac_model
  - ac_power (on, off)
  - load_power (Wh)
  - operation_mode
  - fan_speed
  - swing_mode

## Setup

```yaml
# configuration.yaml

climate
  - platform: xiaomi_miio
    name: Aqara Air Conditioning Companion
    host: <IP_ADDRESS>
    token: b7c4a758c251955d2c24b1d9e41ce47d
    target_sensor: sensor.temperature_158d0001f53706
    scan_interval: 60
```


text:
# Instructions for creating a new release

Jupyter-Book is [hosted on the pypi repository](https://pypi.org/project/jupyter-book/).
To create a new release of Jupyter Book, you need to do these things:

## Before you start

1. Ensure that you have push access to the [Jupyter Book pypi repository](https://pypi.org/project/jupyter-book/)
2. Install [the twine package](https://twine.readthedocs.io/en/latest/). This is a package that helps you
   bundle and push new Python package distributions to pip.
3. Install the [github-activity](https://github.com/choldgraf/github-activity) package to generate a changelog.

## To create the release

To create a new release, [open an issue](https://github.com/ExecutableBookProject/jupyter-book/issues/new) to keep
track of the to-do list for the release. Copy/paste the following markdown into the issue
and check off the boxes as you complete items:

```
- [ ] Ensure that there aren't any extra issues to tackle in
   [the milestone for the next release](https://github.com/ExecutableBookProject/jupyter-book/milestones?direction=asc&sort=due_date)
- [ ] Label any major bug fixes, enhancements, maintenance, and documentation improvements in the merged PRs
- [ ] Ensure that the [Jupyter Book version number](https://github.com/ExecutableBookProject/jupyter-book/blob/master/jupyter_book/__init__.py)
   is correct, and remove the `dev0` part of the version number.
   Make a PR with the new number and merge into master.
- [ ] Delete the extra files we don't want to include in the package, currently this is
      everything in::
    - `jupyter_book/book_template/_site`
    - `jupyter_book/book_template/_build`
- [ ] Create a new distribution for Jupyter Book by
   [following the twine release instructions](https://twine.readthedocs.io/en/latest/#using-twine)
- [ ] Confirm that the new version of Jupyter Book [is posted to pypi](https://pypi.org/project/jupyter-book/)
- [ ] Create a new [release on GitHub](https://github.com/ExecutableBookProject/jupyter-book/releases).

      Call the release simply the version of Jupyter Book you are releasing. Leave the description blank, we'll
      fill it in later.
- [ ] Bump the [Jupyter Book version number](https://github.com/ExecutableBookProject/jupyter-book/blob/master/jupyter_book/__init__.py) to
   the next minor (or major) release and append `dev0` to the end.
- [ ] **Generate a changelog** using the `github-activity` package.

   * See [here for `github-activity` installation instructions](https://github.com/choldgraf/github-activity#installation).
   * Run the generator with this command:

     ```
     github-activity jupyter/jupyter-book --since <<latest-tag>> --until <<new-release-tag>> --auth <<your-github-api-token>> -o tmp.md
     ```
   * It will create a markdown changelog since the last jupyter-book release, and put it
     in `tmp.md`. Copy the sections about **pull requests** and add it
     to [`CHANGELOG.md`](https://github.com/ExecutableBookProject/jupyter-book/blob/master/CHANGELOG.md).
     Ensure that the new version looks correct, then commit it to master.
   * Create a release summary that describes the general changes that have been made,
     add it to the changelog generated by `github-activity. Add this to the new section
     of `CHANGELOG.md`.
   * Commit the new changelog and merge it into master.
- [ ] Copy the resulting markdown for the latest release into the GitHub release you just created.
- [ ] Celebrate! You've just released a new version of Jupyter Book!
```

repository: sarangmittal/jupyter-book

repo_name: sarangmittal/jupyter-book


text:
[![Build Status](https://travis-ci.org/extr0py/oni.svg?branch=master)](https://travis-ci.org/extr0py/oni)
[![Build Status](https://ci.appveyor.com/api/projects/status/gum9hty9hm65o7ae/branch/master?svg=true)](https://ci.appveyor.com/project/extr0py/oni/branch/master)
[![Join the chat at https://gitter.im/extr0py/Lobby](https://badges.gitter.im/extr0py/Lobby.svg)](https://gitter.im/extr0py/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
[![BountySource Active Bounties](https://api.bountysource.com/badge/tracker?tracker_id=48462304)](https://www.bountysource.com/teams/oni)
# Oni
![alt text](./images/Oni_128.png)
## Neovim + JavaScript powered IDE

- [Introduction](#introduction)
- [Features](#features)
- [Installation](#installation)
    - [Windows](#windows)
    - [Mac](#mac)
    - [Linux](#linux)
    - [Build](#build)
- [Documentation](#documentation)
    - [Usage](#usage)
        - [Code Completion](#code-completion)
        - [Fuzzy Finder](#fuzzy-finder)
        - [Quick Info](#quick-info)
    - [Languages](#languages)
        - [JavaScript and TypeScript](#javascript-and-typescript)
        - [C#](c)
    - [Configuration](#configuration)
    - [Extensibility](#extensibility)
    - [FAQ](#faq)
- [Roadmap](#roadmap)
- [License](#license)
- [Contributing](#contributing)
- [Thanks](#thanks)

## Introduction

ONI is a [NeoVim](https://github.com/neovim/neovim) front-end UI with rich IDE-like UI integration points, drawing inspiration from [VSCode](https://github.com/Microsoft/vscode), [Atom](https://atom.io/), and [LightTable](http://lighttable.com/)

This repository is under __active development__, and until 1.0 please consider everything unstable.

Check out [Releases](https://github.com/extr0py/oni/releases) for the latest binaries, or [Build Oni](#build) from source.

## Features

ONI brings several IDE-like integrations to NeoVim:

- **[Quick Info](#quick-info)**

![quick-info-demo](http://i.imgur.com/TlIH97w.gif)

- **[Code Completion](#code-completion)**

![completion-demo](http://i.imgur.com/DVkaIBI.gif)

- **Syntax / Compilation Errors**

![syntax-error-demo](http://i.imgur.com/3ErOKYI.gif)

- **[Fuzzy Finding](#fuzzy-finder)**

![fuzzy-finder-demo](http://i.imgur.com/wYnvcT6.gif)

- **Live Evaluation**

![live-eval-demo](http://i.imgur.com/XenTrdC.gif)

## Installation

Check out [Releases](https://github.com/extr0py/oni/releases) for the latest binary.

Windows & OSX releases come with a bundled Neovim release.

### Windows

- Download the [Oni installer](https://github.com/extr0py/oni/releases/download/v0.2.2-recovery/Oni-0.2.2-ia32-win.exe) for Windows
- Once it is downloaded, run the installer. This will only take a minute.
- By default, Oni is installed under `C:\Program Files (x86)\Oni` for a 64-bit machine.

You can also find install via a [zip archive](https://github.com/extr0py/oni/releases/download/v0.2.2-recovery/Oni-0.2.2-ia32-win.zip)

> You may want to add Oni to your `%PATH%`, so that from the console, you can open Oni via `oni`

### Mac

- Download [Oni](https://github.com/extr0py/oni/releases/download/v0.2.2-recovery/Oni-0.2.2-osx.dmg) for Mac
- Double-click on the archive to expand
- Drag `Oni.app` to the `Applications` folder

### Linux

#### Debian and Ubuntu based distributions

> If you do not have Neovim, follow the instructions to [Install Neovim](https://github.com/neovim/neovim/wiki/Installing-Neovim) and ensure the 'nvim' binary is available. Version `0.2.0` is required..

- Download the [.deb package (64-bit)](https://github.com/extr0py/oni/releases/download/v0.2.2-recovery/oni_0.2.2_amd64.deb)
- Install the package with `sudo dpkg -i <file>.deb`

A [tar.gz](https://github.com/extr0py/oni/releases/download/v0.2.2-recovery/oni-0.2.2.tar.gz) is also available.

#### Red Hat based distributions (Fedora, CentOS)

> If you do not have Neovim, follow the instructions to [Install Neovim](https://github.com/neovim/neovim/wiki/Installing-Neovim) and ensure the 'nvim' binary is available. Version `0.2.0` is required..

- Download the [.rpm package](https://github.com/extr0py/oni/releases/download/v0.2.2-recovery/oni-0.2.2.rpm)
- Install the package with `sudo dnf install <file>.rpm`

A [tar.gz](https://github.com/extr0py/oni/releases/download/v0.2.2-recovery/oni-0.2.2.tar.gz) is also available.

### Build

1) Clone the repository: `git clone https://github.com/extr0py/oni.git`

2) Install dependencies by running `npm install` from the root

3) Build using `npm run build` from the root

4) Run `npm link` to register the *ONI* command

5) Run `oni` at the command line

## Goals

The goal of this project is to provide both the full-fledged VIM experience, with no compromises, while pushing forward to enable new scenarios.

- __Modern UX__ - The VIM experience should not be compromised with poor user experiences that stem from terminal limitations.
- __Rich plugin development__ - using JavaScript, instead of VimL, allowing deep-language integration.
- __Cross-platform support__ - across Windows, OS X, and Linux.
- __Batteries included__ - rich features are available out of the box - minimal setup needed to be productive. TypeScript development is the canonical example, but the hope is that other language providers will be included. Later, an included package manager will make it simple to find and install plugins.
- __Performance__ - no compromises, VIM is fast, and ONI should be fast too.
- __Ease Learning Curve__ - without sacrificing the VIM experience

VIM is an incredible tool for manipulating *text* at the speed of thought. With a composable, modal command language, it is no wonder that VIM usage is still prevalent today even in the realm of modern editors.

However, going from thought to *code* has some different challenges than going from thought to *text*. IDEs today provide several benefits that help to reduce __cognitive load__ when writing code, and that benefit is tremendously important - not only in terms of pure coding efficiency and productivity, but also in making the process of writing code enjoyable and fun.

In my journey of learning VIM and increasing proficiency in other editors, I've found there is always a trade-off - either enjoy the autocompletion and IDE features, and compromise on the experience and muscle memory I've built with VIM, or work in VIM and compromise on the rich language functionality we have in an IDE.

The goal of this project is to give an editor that gives the best of both worlds - the power, speed, and flexibility of using VIM for manipulating text, as well as the rich tooling that comes with an IDE.

## Documentation

### Usage

#### Code Completion

Code completion is a commonly requested add-on to Vim, and the most common solutions are to use a plugin like [YouCompleteMe](https://github.com/Valloric/YouCompleteMe), [deoplete](https://github.com/Shougo/deoplete.nvim), or [AutoComplPop](https://github.com/vim-scripts/AutoComplPop).

These are all great plugins - but they all have the same fundamental issue that they are bounded by the limitations of the Vim terminal UI, and as such, can never be quite up-to-par with new editors that do not have such limitations. In addition, some require an involved installation process. The goal of code completion in ONI is to be able to break free of these restrictions, and provide the same richness that modern editors like Atom or VSCode provide for completion.

##### Entry point

If a [language extension](#language-extensibility) is available for a language, then that language service will be queried as you type, and if there are completions available, those will be presented automatically.

> Out of the box, the only supported languages for rich completion are JavaScript, TypeScript, and C#. JavaScript and TypeScript Language Service which requires either a tsconfig.json or a jsconfig.json at the root of the project. You can use an empty json file with `{}` to get the rich completion. C# uses the [omnisharp](https://github.com/OmniSharp/omnisharp-node-client) service for completion, and will work wherever there is a .csproj file.

##### Commands

- `<C-n>` - navigate to next entry in the completion menu
- `<C-p>` - navigate to previous entry in the completion menu
- `<Enter>` - selected completion item
- `<Esc>` - close the completion menu

##### Options

- `oni.useExternalPopupMenu` - if set to _true_, will render the Vim popupmenu in the same UI as the language extension menu, so that it has a consistent look and feel. If set to _false_, will fallback to allow Neovim to render the menu.

#### Fuzzy Finder

Fuzzy Finder is a quick and easy way to switch between files. It's similiar in goal to the Ctrl-P plugin, and the built-in functionality editors like VSCode and Atom provide.

##### Entry point
- `<C-p>` - show the Fuzzy Finder menu

##### Commands
- `<C-n>` - navigate to next entry in the Fuzzy Finder menu
- `<C-p>` - navigate to previous entry in the Fuzzy Finder menu
- `<Enter>` - select a Fuzzy Finder item
- `<Esc>` - close the Fuzzy Finder menu

By default, Fuzzy Finder uses `git ls-files` to get the available files in the directory, but if git is not present, it will fallback to a non-git strategy.

The Fuzzy Finder strategy can be configured by the `editor.quickOpen.execCommand`, and must be a shell command that returns a list of files, separated by newlines.

#### Command Palette

The Command Palette offers another command-line based interface to Oni.

##### Entry point
 - `<C-P>`

##### Commands
- `<C-n>` - navigate to next entry in the Command Palette menu
- `<C-p>` - navigate to previous entry in the Command Palette menu
- `<Enter>` - select a Command Palette item
- `<Esc>` - close the Command Palette menu

Currently, the Command Palette includes items from:
  - a few commonly used menu items
  - NPM package.json `scripts`
  - Plugin commands
  - Launch parameters from the `.oni` folder

#### Quick Info

Quick Info gives a quick summary of an identifier when the cursor is held on it. JavaScript and TypeScript is supported out of the box.

##### Entry point

Leave the cursor hovering over an identifier.

##### Options

- `oni.quickInfo.enabled` - If set to `true`, the Quick Info feature is enabled. (Default: `true`)
- `oni.quickInfo.delay` - Delay in milliseconds for the Quick Info window to show. (Default: `500`)

### Languages

#### JavaScript and TypeScript

_Configuration_

JavaScript and TypeScript support is enabled out-of-the-box using the [TypeScript Standalone Server](https://github.com/Microsoft/TypeScript/wiki/Standalone-Server-(tsserver)). No setup and configuration is necessary, however, you will get better results if you use a `tsconfig.json` or a `jsconfig.json` to structure your project.

_Supported Language features_

| Completion | Goto Definition | Formatting | Enhanced Syntax Highlighting | Quick Info | Signature Help | Live Evaluation | Debugging |
| --- | --- | --- | --- | --- | --- |--- | --- |
| Y | Y | Y | Y | Y | Y | Y | N |

#### C#

_Configuration_

C# completion uses the [OmniSharp Node Client](https://github.com/OmniSharp/omnisharp-node-client) which provides language capabilities for both .NET and Mono. For it to work correctly, you need to have a valid `.csproj` file with any dependent packages (ie, Nuget) installed. The project should also build and compile for the language service to work correctly.

> If you are using the .NET Core CLI, make sure to run `dotnet restore` on your project.

_Supported Language features_

| Completion | Goto Definition | Formatting | Enhanced Syntax Highlighting | Quick Info | Signature Help | Live Evaluation | Debugging |
| --- | --- | --- | --- | --- | --- |--- | --- |
| Y | Y | N | N | Y | N | N | N |

_Known Issues_

- On Windows, you must run Oni as an administrator the first time using the C# language service. This is tracked by issue [#423](https://github.com/extr0py/oni/issues/423).
- On all platforms, the C# language service takes time to start up, especially the first time as it is downloading the appropriate runtime environment. You can open up the developer tools (Help -> Developer Tools) to see the logging from the language service. [#424](https://github.com/extr0py/oni/issues/424) tracks making this logging more visible.

### Configuration

> ONI is configurable via a 'config.js' located in $HOME/.oni

Here's an example config.js:
```
module.exports = {
    "oni.useDefaultConfig": true,
    "oni.loadInitVim": true,
    "editor.fontSize": "14px",
    "editor.fontFamily": "Monaco",
    "editor.completions.enabled": true
}
```

A few interesting configuration options to set:
- `oni.audio.bellUrl` - Set a custom sound effect for the `bell` (`:help bell`). The value should be an _absolute path_ to a supported audio file, such as a WAV file.
- `oni.useDefaultConfig` - ONI comes with an opinionated default set of plugins for a predictable out-of-box experience. This will be great for newcomes to ONI or Vim, but for Vim/Neovim veterans, this will likely conflict. Set this to `false` to avoid loading the default config, and to load settings from `init.vim` instead (If this is false, it implies `oni.loadInitVim` is true)
- `oni.loadInitVim` - This determines whether the user's `init.vim` is loaded. Use caution when setting this to `true` and setting `oni.useDefaultConfig` to true, as there could be conflicts with the default configuration.
- `oni.exclude` - Glob pattern of files to exclude from Fuzzy Finder (Ctrl-P).  Defaults to `["**/node_modules/**"]`
- `oni.hideMenu` - (default: `false`) If true, hide menu bar.  When hidden, menu bar can still be displayed with `Alt`.
- `editor.fontSize` - Font size
- `editor.fontFamily` - Font family
- `editor.fontLigatures` - (default: `true`). If true, ligatures are enabled.
- `editor.backgroundImageUrl` - specific a custom background image
- `editor.backgroundImageSize` - specific a custom background size (cover, contain)

See the `Config.ts` file for other interesting values to set.

In VimL, the `g:gui_oni` variable will be set to `1`, and can be validated with `if exists("g:gui_oni")` in VimL.

### Extensibility

ONI offers several rich extensibility points, with the focus being on various UI integrations as well as IDE-like capabilities.

#### Language Extensibility

Language extenders given ONI rich integration with languages, offering services like:

- Code Completion
- Quick Info
- Goto Definition
- Formatting
- Live code evaluation
- Unit test integration
- Enhanced syntax highlighting

To see the in-progress API, check out the [Oni.d.ts](https://github.com/extr0py/oni/blob/master/definitions/Oni.d.ts) definition file as well as the [typescript language plugin](https://github.com/extr0py/oni/tree/master/vim/core/oni-plugin-typescript), which demonstrates several of these features:

#### Background

ONI currently supports the setting of a background image as well as background opacity.

#### Debuggers

#### Project Templates

#### Snippets

### FAQ

#### Why isn't my init.vim loaded?

> _TL;DR_ - Set the `oni.useDefaultConfig` configuration value to _false_

By default, Oni has an opinionated, prescribed set of plugins, in order to facilitate a predictable out-of-box experience that highlights the additional UI integration points. However, this will likely have conflicts with a Vim/Neovim veteran's finely-honed configuration.

To avoid loading the Oni defaults, and instead use your `init.vim`, set this configuration value to false in $HOME/.oni/config.json.

### Included VIM Plugins

This distribution contains several VIM plugins that enhance the VIM experience.

These are:
- [targets.vim](https://github.com/wellle/targets.vim)
- [typescript-vim](https://github.com/leafgarland/typescript-vim)
- [vim-commentary](https://github.com/tpope/vim-commentary)
- [vim-unimpaired](https://github.com/tpope/vim-unimpaired)

As well as some color-schemes:
- [vim-monokai](https://github.com/sickill/vim-monokai)
- [onedark.vim](https://github.com/joshdick/onedark.vim)

## Roadmap

See [roadmap](ROADMAP.md)

## License

MIT License. Copyright (c) extropygames

The bundled plugins have their own license terms, along with the bundled Neovim binary

## Contributing

Contributions are very much welcome :)

If you're interested in helping out, check out [CONTRIBUTING.md](./CONTRIBUTING.md) for tips and tricks for working with ONI.

# Thanks

Big thanks to the NeoVim team - without their work, this project would not be possible. The deep integration with VIM would not be possible without the incredible work that was done to enable the msgpack-RPC interface. Thanks!

Also, big thanks to our [contributors](https://github.com/extr0py/oni/graphs/contributors) for helping out!

In addition, there are several other great NeoVim front-end UIs [here](https://github.com/neovim/neovim/wiki/Related-projects) that served as great reference points and learning opportunities.

There are a few image and audio assets bundled with Oni - see [ASSETS.md](ASSETS.md) for attribution.

Special thanks to [Till Arnold](https://github.com/tillarnold) for handing over the `oni` NPM package name.

repository: foxoman/oni

repo_name: foxoman/oni


text:
Opinionated customisations for vim.

Uses hijackey-vim (https://github.com/louispan/hijackey-vim) to enable Ctrl+Shift+Alpha key combinations.

# Installation

If you are using Vundle, add the following to your `.vimrc`:

```
Plugin 'louispan/esoteric-vim'
if filereadable(expand("~/.vim/bundle/esoteric-vim/bundle/bundle.vim"))
    source ~/.vim/bundle/esoteric-vim/bundle/bundle.vim
endif
```

Then at the end of your .vimrc
```
call esoteric#esoteric#setup()
```

See https://github.com/louispan/esoteric/blob/master/etc/.vimrc for an example.

For more control, look at the definition esoteric#esoteric#setup to only turn
particular esoteric settings on.

repository: louispan/esoteric-vim

repo_name: louispan/esoteric-vim


text:
# Data Analytics with the Fisher Iris Dataset
Data Science Course Assignment - Indian Institute of Technology Ropar

## Abstract

This document summarizes the results of data exploration and data classification per-
formed on the Fisher Iris Dataset. The Iris Dataset contains the samples of four different
features from three different species of Iris flower. The features include the length and
width of the sepals and petals measured in centimetres. Histogram, scatter plots and
box plot of the features are included for the exploration of data. Logistic Regression,
Gaussian Naive Bayes and K-Means algorithms are used to classify the data by using
the five-fold cross-validation technique. For each algorithm, the confusion matrix is
tabulated and classification report is generated. The performance of each algorithm on the
given dataset is also compared.

## 1 Dataset

The Iris flower data set or Fisher’s Iris data set is a multivariate data set introduced by the
British statistician and biologist Ronald Fisher in his 1936 paper The use of multiple mea-
surements in taxonomic problems as an example of linear discriminant analysis. It is some-
times called Anderson’s Iris data set because Edgar Anderson collected the data to quantify
the morphological variation of Iris flowers of three related species. Two of the three species
were collected in the Gaspé Peninsula "all from the same pasture, and picked on the same
day and measured at the same time by the same person with the same apparatus".
The data set consists of 50 samples from each of three species of Iris (Iris setosa, Iris
virginica and Iris versicolor). Four features were measured from each sample: the length
and the width of the sepals and petals, in centimeters. Based on the combination of these
four features, Fisher developed a linear discriminant model to distinguish the species from
each other.

## 2 Data Exploration

Used various methods to explore the data in Iris Dataset including the correlation heatmap,
histograms, scatter plot and box plot. Each of these has provided different insights into
the data. It is found that there are no null entries in the dataset which is good. The major
conclusions are given below along with the plots.

Figure 1: (a)Correlation Heat map for different features. (b)Scatter plot with Petal Length(x)
and Petal Width(y) for all data points. (c)Distribution of Sepal Width(y) by grouping Sepal
Length(x) into 5 or 10 bins.

### 2.1 Description

### 2.2 Correlation Heatmap

Plotted the heatmap to show the correlation between the features. It can be seen in figure
1(a) that there is a very high correlation between petal width and petal length with a corre-
lation coefficient of 0.96. The correlation of sepal length and petal length and also the sepal
length and petal width is found to be positive with a correlation coefficient of 0.87 and 0.
respectively. However, there is a negative correlation between sepal width and petal length
and sepal width and petal width with the correlation coefficient of -0.43 and -0.37.

### 2.3 Scatter Plot

Made a scatter plot with Petal Length (x) and Petal Width (y) for all the values in the dataset.
It was analysed that the points increased linearly. The overall petal length and petal width
were longer for the Virginica species whereas it was shorter for the Setosa species ( too short
in comparison ). However, for the Versicolor species, the lengths were closer to the Virginica
species. The scatter plot is given in the figure 1(b).

### 2.4 Box Plot

The median for the virginica species is always greater than the two other species but not in
the case of sepal width. Also in every boxplot the length of the box and whiskers show the
variation of values from average value. The variation is again high for virginica in the first

Figure 2: (a)Box plot for petal length(cm) (b)Box plot for petal width(cm) (c)Box plot for
sepal length(cm) (d)Box plot for sepal length(cm)

three cases but for sepal width, it is less. The number of outliers is more virginica for sepal
width and for setosa in the case of petal length and petal width. However the average sepal
width is more for setosa than the other two species.

## 3 Logistic Regression

Fitted the Logistic Regressor on the dataset for five-fold cross-validation.
Hence the average accuracy for the model is 96%.
Also plotted the confusion matrix and tabulated the classification report for the model.

## 4 Gaussian Naive Bayes

Performed the five-fold cross-validation on the dataset for the Gaussian Naive Bayes too.
The average accuracy came out to be 95.33%
Also plotted the confusion matrix and tabulated the classification report for the Gaussian
Naive Bayes model.

## 5 K-Means

Used the complete dataset to train the KMeans model. Plotted the confusion matrix for the
model. Also performed PCA to plot the misclassified data points on a scatter plot.

## 6 Conclusion

The logistic regression and Gaussian Naive Bayes performed well on the dataset whereas
the performance of the KMeans classifier was satisfactory. Also the results for the KMeans
varied with multiple runs as it depends on the initial centroids chosesn randomly. Also there
were some outlier in the dataset which too affected the performance of the models. However
they can be removed from dataset to make it more clean and better for training.
The things that I learn are that K-Fold Cross-Validation significantly increase the perfor-
mance of a model and also aware us about the fitting of the model on the dataset and protect
it from overfitting on the data.


text:
# Work Log
## Week 3
## 1/28/2020
Met with Shane Panter in class. Had no updates for him because we had not met with our project sponsor yet.

## 1/30/2020
Met with sponsor Jared. Had our picture taken for the ID badge. Started to discuss the scope/semantics of our project with sponsors.
Meeting notes:
  Development stack
   - Angular - Frontend
   - Python Flask web service - Backend
   - MySQL database - Backend
   - Docker
  Using Docker to virtualize frontend and backend
  Homework specific for myself
    - Review Masabi API documentation
    - Create Doodle poll for group member availability for extra (outside of class) meetings
    - Set up my machine with the tools/software listed in development stack

## Week 4
## 2/1/2020
Completed Doodle poll for my availability
Set up my local machine with the development stack
Reviewed Masabi API documentation

## 2/4/2020
Met with Shane Panter in class. Had no updates for him. We discussed the conversation our team had with the sponsors.

## 2/6/2020
Met with sponsor. Started to plan the design around the two user stories we came up with during our first meeting. Those being:
   - As an Employer/Staff I want to add passes to an Employee/Student
   - As a CityGo admin I want to adminster Employees
Questions for Masabi:
  - What identifies an account (Rider object in API diagram)?
  - Can we get that information for an existing account?
Questions for Katie:
  - What type of passes are we going to adminster to Employees? 31 day pass, permanent pass?
Homework specific for myself
  - Add initial Angular files to our project code base
     Accomplished with ng new
  - Look into using a third party to manage logins to our front end

## Week 5
## 2/13/2020
Use Google single sign in to manage login authentication.
Developed more clear questions for Katie:
  What type of ticket do we provision?
  Login system would we be limited to
    Google SSO
    Amazon
    Auth0
  Will users be able to buy other passes using CityGo account
Developed more clear questions for Masabi:
  What identifies a rider?
  Do we have access to that Resource?
  Access to product?
Upon termination grace period is remaining employee pass
Employer pays CityGo base membership, pushing passes
Employer pays CityGo base membership, not pushing passes
Unaffiliated, city go manages pushing passes

## 2/18/2020
Met with Shane. Updated him on the meeting our team had with Transit last week.

## Week 7
## 2/20/2020
Developed a clear path of development for our team to follow. Decided we will only deal with 31 day passes.
Homework specific for myself
  - Create Flask application with a MySQL connector library imported.
  - Track development using an Agile Development workflow with Zenhub.

## 2/25/2020
Met with Shane. Expressed that our team finally has a clear path to follow. Katie attended the meeting last week and cleared up the waters.

## Week 8
## 2/27/2020
Met with Jared, gave the status of our work during sprint 1, discussed future work and outlined below:
| Stories               | Task                                             |
|-----------------------|--------------------------------------------------|
| Flask                 | Create endpoints as needed                       |
| Angular Admin View    | Admin data request                               |
| CityGo                | Setup test users                                 |
| Masabi                | Use POST/PUT data changing requests to their api |
| Angular Employer View | Employer data request                            |
| Auth0                 | Questions about login whitelist                  |

## 3/2/2020
Out of class sick. Continued to work on Angular frontend development. Finished a dynamic front end table for city go admin view

## Week 9
Continued to work on city go admin view. Made an expandable table (rows expand with more information on a specific employer). Finished adding an add employer button.

## Week 10
Spring break.

## Week 11
Assigned to work on backend security. Researching Python Flask JWT as a method to accomplish protecting the backend endpoints. Also need to look into using Auth0 in conjunction with JWT to protect backend endpoints. Also added fake data to city go admin view for our presentation/demo. We will be conducting a zoom meeting and recording it. Each of us will share screens and demo what we have worked on.

repository: justinsonnen/Capstone

repo_name: justinsonnen/Capstone


text:
Divvy is a Decentralised Dapp made on Web3. It's a Marketplace for artists to sell their digital assets, earn royality and make some sales on the polygon matic network.

Made with ♥ using  and  by Piyush Mehta

### Wallets Compatible
• [MetaMask](https://metamask.io)

### Crypto Currency for exchange of NFTs
• [Polygon Matic](http://polygon.technology)

## How to run this project locally

### Prerequisites

1. Git
1. Node: any 12.x version starting with v12.0.0 or greater
1. Yarn: See Yarn website for installation instructions
1. A fork of the repo (for any contributions)

### 1. Setting up local env

1. Create `secret.js` in the root of the project

```js
// secret.js get private key and project id from https://infura.io

const PRIVATE_KEY = "your private key"
const PROJECT_ID = "your project id"
module.exports = { PRIVATE_KEY, PROJECT_ID };

```

2. Installing dependencies

```bash
 ➜ yarn install
```

3. Install [Metamask](https://metamask.io) on your choice of browser

### 2. Running the blockchain locally

```bash
  ➜ npx hardhat test # To test the smart contract
  ➜ npx hardhat run scripts/deploy.js --network localhost # To get cred for local network
  ➜ npx hardhat node # create a local node
```

### 3. Running the frontend locally

```bash
  ➜ yarn dev
```

_____________________

Made with ❤ by Piyush Mehta


text:
# Change Log

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

The format is based on [Keep a Changelog](http://keepachangelog.com/)
and this project adheres to [Semantic Versioning](http://semver.org/).

## [1.0.1] - 2018-04-13

### Fixed

- Fixed missing methods in the "stdin", "identity" and "noop" processors

## [1.0.0] - 2018-04-13

### Added

- Better schema capabilities: full support for following & paginating at any level
- New parse helpers: DOM elements matchers
- New parse helpers: date, uuid and static text extractors
- HTTP file system cache
- Pagination template support for the "http" loader `url` option
- Pagination template support for the "file" loader `path` option

### Removed

- Removed the JSON parser

### Changed

- Updated the demos

repository: vmdao/jason-the-miner

repo_name: vmdao/jason-the-miner


text:
# jenkins-shared-library

Jenkins Shared Library Example. A Jenkins shared library is a collection of independent groovy scripts which can be used in Jenkins pipeline runtime.

1. You should add shared library from **Manage Jenkins** screen.
2. You can load the shared library at top of Jenkinsfile.

```groovy
@Library('my-jenkins-shared-library') _

mavenPipeline(
    appName: "my-awesome-app"
)
```

## library structure

Shared library will follow folder structure like this.

```
jenkins-shared-library
|____vars
|____src
|____resources
```

The `vars` directory includes all global scripts can be called directly from a pipeline.
The `src` directory is a regular java source directory, it will be added to classpath during every script compilation.
The `resources` directory will hold all the non-groovy files that required by your pipeline.

## usage example

The repo demonstrates a possibility of shared library implementation, the minimum example:

```groovy
@Library('jenkins-shared-library') _

mavenPipeline(
    appName: "my-awesome-app"
)
```

Above example will create a pipeline for maven project with specified stages:

1. Initialize
2. PreBuild
3. BuildArtifacts
4. SonarQube
5. Deploy
6. AutomationTest
7. Finalize

TODO: add a pipeline picture here.

It is very easy to apply these stages to Gradle projects.

```groovy
@Library('jenkins-shared-library') _

gradlePipeline(
    appName: "my-awesome-app"
)
```

Or nodejs project.

```groovy
@Library('jenkins-shared-library') _

nodejsPipeline(
    appName: "my-awesome-app"
)
```

## advanced usage

We may want to customize the pipeline in some case, example as:

```groovy
@Library('jenkins-shared-library') _

mavenPipeline(
    appName: "my-awesome-app",
    buildFunc: {
        sh "./build.sh"
    }
)
```

The full example of pipeline customization.

```groovy
TODO
```

## copyright & license

This is a demo of my jenkins shared library, no maintenance and support provided.

License under MIT.

repository: tobyqin/jenkins-shared-library

repo_name: tobyqin/jenkins-shared-library


text:
# Espresso bin board
Configurations on Marvell ARMADA 3700

# Basic configuration:
* Install Ubuntu 16.04.3 TLS:
   http://espressobin.net/wp-content/uploads/2017/10/ebin-ubuntu-16.04.3.zip

* Include Kernel 4.4.8:
  http://espressobin.net/wp-content/uploads/2017/02/kernel.zip

Note: ebin-ubuntu-16.04.3 includes kernel 4.4.52, that has frequent panics.
I suggest overwriting it using 4.4.8

# Network configuration
If you attached WAN to your router,
and need network to be up on reboot:

/etc/network/interfaces

```
auto eth0
iface eth0 inet manual
post-up /sbin/dhclient wan
```

# Serial connection

For a serial connection to a board from your MacOS, this software works well:

https://pbxbook.com/other/mac-tty.html

```
brew install c-kermit

cat > ~/kermit-connect.conf
set line /dev/tty.usbserial
set speed 115200
set carrier-watch off
set flow-control none
set handshake none
set prefixing all
set streaming off
set parity none
connect
# Control+D to stop cat input

kermit ~/kermit-connect.conf

```

# LED

When you connect DC 12V power, green LED lights up.
I was looking if there is a way to dim or turn it off through GPIO.

I don't see any so far.

Looking as the board it is labeled "LED3".
In [current schematics](http://espressobin.net/wp-content/uploads/2017/08/ESPRESSObin_V5_Schematics.pdf)

Looks like it's directly connected to power through a resistor `R48`.
There are couple capasitors and zener diodes around, which does not help.

Why would you build in high intensity LED, for such a simple thing as indicating power?

repository: antontsv/espresso

repo_name: antontsv/espresso


text:
![Half-Life Logo](http://files.gamebanana.com/img/ico/sprays/51f5acee815f0.png)

# Docker image for Half-Life Dedicated Server (Counter Strike 1.6 + podbot + display_damage + maps)

### Build an image:

```
 $ git clone https://github.com/h3ct0r/counter-strike-docker
 $ make build
```

### Create a server token with your steam user

Login and create a token at:  https://steamcommunity.com/dev/managegameservers
This token is not *mandatory*, but using it will enable adding your server to the Steam server list so others can join and play without too much hazzle.

### Port forwarding (If going to play outside of your LAN using internet)

- **UDP/TCP 27015** - Main connection port (MUST). This is the port and protocol used by the server browser, allows clients to connect. TCP is used for in-game RCON
- **UDP 27020** - SourceTV (if enabled). You can disable this port by adding "-nohltv" to the start up command.
- **UDP 27005** - This is an outgoing connection used by clients. Typically you would not need to open this port in your firewall because this is for OUTBOUND connections.

### Create and start new Counter-Strike 1.6 server:

```
$ docker run -d -p 27005-27020:27005-27020/udp -p 27005-27020:27005-27020 -e MAXPLAYERS=16 -e START_MAP=de_dust2 -e ADMIN_STEAM={YOUR_STEAM_ID} -e SERVER_NAME="{YOUR_GAME_SERVER_NAME}" --name cs counter_strike_16:latest +sv_setsteamaccount {YOUR_SERVER_TOKEN} +sv_password {YOUR_GAME_PASSWORD} +rcon_password {YOUR_REMOTE_COMMAND_PASSWORD} +sv_lan 0
```

- **MAXPLAYERS** : maximum number of players for this game session.
- **START_MAP** : the map that will be used when game starts.
- **ADMIN_STEAM** : your steam_id. This setting will allow the user of the defined steam_id to control the server. The steam_id can be found using the comand `status` in the game console. Add this id without the 'STEAM_' part. Example: '0:1:22545666'.
- **SERVER_NAME** : the name of game the server displayed to the players.
- **+sv_setsteamaccount** : the token from the developer server account. This in theory allows this server to be displayed into the server list in Steam. It is recommended from the Steam tutorial, but dont know if this is obligatory.
- **+sv_password** : the password of your game session. The users will need to set this password to enter the game.
- **+rcon_password** : the remote administrator password for this game instance. The RCON command list can be seen in https://github.com/h3ct0r/counter-strike-docker/wiki/RCON-Commands
- **+sv_lan**: allow remote conections outside your LAN

### Stop the server:

```
 docker stop cs
```

### Start existing (stopped) server:

```
 docker start cs
```

### Remove the server:

```
 docker rm cs
```

### How clients can connect to this server?

From the Counter Strike console (press ')
```
connect <IP_ADDRESS>:27015; password server_password
```

### PodBot administration

From the console (inside the game press ') set the environment variable _pbadminpw:

```
setinfo _pbadminpw "your_password"
```

Then activate the podbot menu:

```
pb menu
```

### Use image from [Docker Hub](https://hub.docker.com/r/h3ct0rxxx/counter_strike_16):

```
 $ docker run -d -p 27005-27020:27005-27020/udp -p 27005-27020:27005-27020 -e MAXPLAYERS=16 -e START_MAP=de_dust2 -e ADMIN_STEAM=YOUR_ADMIN_STEAM_ID -e SERVER_NAME="TEST SERVER DE_DUST2 ROLF" --name cs h3ct0rxxx/counter_strike_16:latest +sv_setsteamaccount YOUR_STEAM_TOKEN_ID +sv_password YOUR_GAME_PASSWORD +rcon_password YOUR_RCON_PASSWORD +sv_lan 0 +log
```

### Todos

 - Write MORE Tests
 - Add more interesting plugins
 - Add sounds?!
 - Add fast server for game assets

License
----

Apache2

**Free Software, Hell Yeah!**


text:
---
title: K3s
linktitle: K3s
type: docs
description: Setup Jenkins X on a K3s cluster running locally
date: 2021-11-22
publishdate: 2021-11-22
lastmod: 2021-11-22
weight: 50
aliases:
  - /v3/admin/platform/k3s
---

{{< k8s-versions >}}

**NOTE**

Ensure you are logged into GitHub else you will get a 404 error when clicking the links below

This guide will walk you though how to setup Jenkins X on your laptop using [k3s](https://k3s.io/)

If you are on Mac OS, you can follow this [guide](https://docs.kalm.dev/install/install-local-k3s/) to set up k3s.
You do not need to install kalm for the rest of the tutorial.

### Prerequisites

#### K3s

Make sure you have created a cluster using k3s.

If you dont have an existing k3s cluster, you can install one by running:

```bash
curl -sfL https://get.k3s.io | INSTALL_K3S_CHANNEL=v1.24 sh -s - --write-kubeconfig-mode 644
sudo cp /etc/rancher/k3s/k3s.yaml ~/.kube/k3s-config
# Set it also in the bashrc or zshrc file, or you can flatten both of these configs into a single file
export KUBECONFIG=~/.kube/config:~/.kube/k3s-config

```

To verify that k3s has been installed successfully, and configured run:

```bash
kubectl get nodes
```

- You will need to open multiple terminals later, so setting these env variables in the bashrc or zshrc might help you

```bash
nano ~/.bashrc
#go to the end of the file and paste the export command
export KUBECONFIG=~/.kube/config:~/.kube/k3s-config
```

**Optional**

- If the above method didn't work, copy the configurations to the ~/.kube/config instead (if you don't have any other clusters, that should be fine)

```bash
sudo rm ~/.kube/k3s-config  #to make k3s uses ~/.kube/config
sudo cp /etc/rancher/k3s/k3s.yaml ~/.kube/config
```

- If still got `permission denied`

```bash
sudo chmod 777 ~/.kube/config #warning: this maybe vulnerable to multiple users
```

This value of the node will be used later during installation and configuring of Jenkins X.

Check [k3s install guide](https://rancher.com/docs/k3s/latest/en/installation/) for more installation options.

#### Vault

Install vault cli.
Refer to the [vault docs](https://www.vaultproject.io/docs/install) on how to install vault for your platform.

##### Internal vault (Preferred)

###### Helm

Follow the [helm documentation](https://helm.sh/docs/intro/install/) to install the helm binary.
Once helm is installed, proceed to the next steps.

To install vault inside the newly created k3s cluster, you need to install the vault operator and vault instance chart.

```bash
helm repo add banzaicloud-stable https://kubernetes-charts.banzaicloud.com
helm repo add jxgh https://jenkins-x-charts.github.io/repo
helm repo update
helm install vault-operator banzaicloud-stable/vault-operator --create-namespace -n jx-vault
helm install vault-instance jxgh/vault-instance -n jx-vault
```

Wait for the vault pods to be in running status, before proceeding to the next steps.

```bash
kubectl get pods -n jx-vault
```

Output should be similar to

```bash
NAME                                READY   STATUS    RESTARTS   AGE
vault-operator-d7c697f95-55dfj      1/1     Running   0          4m22s
vault-0                             3/3     Running   0          4m10s
vault-configurer-689758f67d-8npcf   1/1     Running   0          3m38s
```

##### External vault

###### Docker

You need to install [docker](https://docs.docker.com/engine/install/) and [manage it as a non root user](https://docs.docker.com/engine/install/linux-postinstall/)

Make sure you have vault running in a docker container with kubernetes auth enabled.

```bash
docker run --name jx-k3s-vault -d --cap-add=IPC_LOCK -e 'VAULT_DEV_ROOT_TOKEN_ID=myroot' -e 'VAULT_DEV_LISTEN_ADDRESS=<IP_ADDRESS>:8200' --net host vault:latest
```

To verify if vault started properly use `docker logs jx-k3s-vault`.

Next enable kubernetes auth in vault.

```bash
export VAULT_ADDR='http://<IP_ADDRESS>:8200'
# you may want to set this at the end of the ~/.bashrc file or ~/.zshrc either to be accesible for all terminals you open like the way we did above
vault auth enable kubernetes
```

Note: If you get the error `Error enabling kubernetes auth: Post "https://<IP_ADDRESS>:8200/v1/sys/auth/kubernetes": http: server gave HTTP response to HTTPS client`, try the command `vault login myroot`.

#### Github

- Create a git bot user (different from your own personal user) e.g. https://github.com/join and generate a a personal access token, this will be used by Jenkins X to interact with git repositories. e.g. https://github.com/settings/tokens/new?scopes=repo,read:user,read:org,user:email,write:repo_hook,delete_repo,admin:repo_hook,write:packages
- This bot user needs to have write permission to write to any git repository used by Jenkins X. This can be done by adding the bot user to the git organisation level or individual repositories as a collaborator Add the new bot user to your Git Organisation, for now give it Owner permissions, we will reduce this to member permissions soon.

#### Jenkins-X

- Make sure you have installed [jx 3.x binary](https://jenkins-x.io/v3/admin/setup/jx3/) and put it on your `$PATH` as the `jx admin operator` will be used

### Jenkins X v3 installation

- Generate a cluster git repository from the [jx3-k3s-vault](https://github.com/jx3-gitops-repositories/jx3-k3s-vault) template, by clicking [here](https://github.com/jx3-gitops-repositories/jx3-k3s-vault/generate)
- Clone the generated repository and cd into the repository folder
- Set up ingress and webhook

  - Get the external IP of the traefik service (loadbalancer)

  ```bash
  kubectl get svc -A | grep LoadBalancer
  kube-system   traefik          LoadBalancer   <cluster-ip>    <external-ip>    80:31123/TCP,443:31783/TCP   40m
  ```

  - Edit the jx-requirements.yaml file by editing the ingress domain:

  ```bash
  jx gitops requirements edit --domain <external-ip>.nip.io
  ```

- set up Ngrok

  - Refer to [these docs](/v3/develop/faq/ngrok/) to set up ngrok

  - Once this tunnel is open, paste the ngrok url (without http) which is forwarding the traffic to port 8080 in the hook field in the helmfiles/jx/jxboot-helmfile-resources-values.yaml file in the cluster git repository.
  - commit and push the changes.

  ```bash
  git add .
  git commit -m "chore: initial commit"
  git push origin main
  ```

- Make these changes only when using external vault

  - Add the value of the vault url in the `jx-requirements.yaml` file.

  ```bash
  vault:
    url: http://<replace with k3s node name>:8200
  ```

  The jx-requirements file should look like this for external vault:

  ```bash
  secretStorage: vault
  vault:
    url: http://<replace with k3s node name>:8200
  ```

  - Commit and push your changes:

  ```bash
  git add .
  git commit -m "fix: set vault url"
  git push origin main
  ```

- Set the GIT_USERNAME (bot username) and GIT_TOKEN (bot personal access token) env variable and run:

  - Internal vault

  ```bash
  jx admin operator --username $GIT_USERNAME --token $GIT_TOKEN --url <url of the cluster git repo>
  ```

  - External vault

  ```bash
  jx admin operator --username $GIT_USERNAME --token $GIT_TOKEN --url <url of the cluster git repo> --set "jxBootJobEnvVarSecrets.EXTERNAL_VAULT=\"true\"" --set "jxBootJobEnvVarSecrets.VAULT_ADDR=http://<replace with k3s node name>:8200"
  ```

  > Note (Only for external vault): The first job will fail as it cannot authenticate against vault.
  > The errors will be of the form `error: failed to populate secrets: failed to create a secret manager for ExternalSecret`.
  > Once the secret-infra namespace has been created, we can configure vault.
  > If you get an error connecting to the cluster, try running `kubectl config view --raw >~/.kube/config` as well as checking the permissions/owner of `~/.kube/config`

### Vault configuration (Only for external vault)

Install [jq](https://stedolan.github.io/jq/download/) before running these commands.

Remember to run the following commands in a terminal where you have set the value of `VAULT_ADDR`

- Create a vault config

```bash
export VAULT_ADDR='http://<IP_ADDRESS>:8200'
export VAULT_HELM_SECRET_NAME=$(kubectl -n secret-infra get secrets --output=json | jq -r '.items[].metadata | select(.name|startswith("kubernetes-external-secrets-token-")).name')
export TOKEN_REVIEW_JWT=$(kubectl -n secret-infra get secret $VAULT_HELM_SECRET_NAME --output='go-template={{ .data.token }}' | base64 --decode)
export KUBE_CA_CERT=$(kubectl config view --raw --minify --flatten --output='jsonpath={.clusters[].cluster.certificate-authority-data}' | base64 --decode)
export KUBE_HOST=$(kubectl config view --raw --minify --flatten --output='jsonpath={.clusters[].cluster.server}')

# you may want to set this at the end of the ~/.bashrc file or ~/.zshrc either to be accesible for all terminals you open like the way we did above

vault write auth/kubernetes/config \
        token_reviewer_jwt="$TOKEN_REVIEW_JWT" \
        kubernetes_host="$KUBE_HOST" \
        kubernetes_ca_cert="$KUBE_CA_CERT" \
        disable_iss_validation=true
```

- Create a vault role:

```bash
vault write /auth/kubernetes/role/jx-vault bound_service_account_names='*' bound_service_account_namespaces=secret-infra token_policies=jx-policy token_no_default_policy=true disable_iss_validation=true
```

- Create a policy attached to vault role:

```bash
vault policy write jx-policy - <<EOF
path "secret/*" {
  capabilities = ["sudo", "create", "read", "update", "delete", "list"]
}
EOF
```

Once vault is configured, pull the changes commited to the cluster git repository by the bootjob, and push a dummy job

```bash
git pull
# Make a dummy change (change Readme file for example)
git add .
git commit -m "chore: dummy commit 1"
git push origin main
```

tail the logs of `jx-git-operator` pod in the `jx-git-operator` namespace.

```bash
not creating a Job in namespace jx-git-operator for repo jx-boot sha XXXXXX yet as there is an active job jx-boot-XXXXXXX
```

Kill that job.

```bash
kubectl delete job jx-boot-97dbb72f-4e4e-4b0e-8eb2-8908997b19f7 -n jx-git-operator
```

Once it's killed a new boot job will be triggered.
This job will create the secrets in vault which will be used by external secrets to create kubernetes secrets.

- To verify the job succeeded, run `jx admin log`
- To verfiy the secrets were created, run `kubectl get es -A` and `jx secret verify`
- If this didn't work try and repeat the steps but commit your dummy changes through github repository directly other than the `git push origin main` command

### Port forwarding for webhooks

In another terminal run the following command to enable webhooks via ngrok

```bash
jx ns jx
kubectl port-forward svc/hook 8080:80
```

- Once the bootjob has succeeded, you should see:

```bash
HTTP Requests
-------------

POST /hook                     200 OK
```

### Next steps

- Create or import projects

repository: jenkins-x/jx-docs

gha_language: HTML

repo_name: jenkins-x/jx-docs


text:
# This project has moved to [djangophyics](https://github.com/fmeurou/djangophysics)
And [geocurrency.me](https://www.geocurrency.me) is moving to [geophysics.io](https://www.geophysics.io)

# Geocurrency

Django APIs for Physics

## Countries
 List of countries according to ISO-3166 and details of a country based on PyCountry module.

## Currencies
 List of currencies based on ISO-4217

## Currencies conversion rates
List of conversion rates fetched from BCE APIs.
The module provides a command line for fetching rates from different services. Custom services can be added.
Custom conversion rates can be created by registered users.

## Systems and Units
List of unit systems, dimensions, and units based on the excellent Pint library.
Custom units can be created by registered users.

## Conversions
Conversions between currencies, with batch conversion support.
Conversions between units in a unit system with batch conversion support

## Evaluation
Check the syntax and dimension of a formula with units, and evaluate its value

## Install

pip install geocurrency

## Docker

doocker is available at fmeurou/geocurrency

## Usage

### Routes
This package provides a OpenAPI documentation. See urls.example.py for a setup example.

### Authentication
The app provides most services without authentication.
Authentication is required to store custom conversion rates and custom conversion units.
By default, the app is configured to allow authentication through an API token that can be generated for a user on the
Django admin site.

API authentication can be achieved with an Authorization header header with value Token <APIToken>
curl -H "Authorization: Token <user token>".

### Language support
The app supports translations for countries and units in 15 languages. More languages should be available soon.

### Fetch rates
The app uses python-forex as a mecanism to fetch currency rates.
A django command is available to fetch rates from command line :
$ ./manage.py fetch_rates

## About

### Project goals

Web based services to convert units and currencies.
GeoCurrency is a portmanteau of the words "Geocoding" and "Currency" which where the main goals of the initial project

### Project website
A live version of this service is available at <https://api.geocurrency.me>.

### Leadership

This project is maintained by Frédéric Meurou<EMAIL_ADDRESS>

repository: fmeurou/geocurrency

gha_language: Python

repo_name: fmeurou/geocurrency


text:
# Document Ready

Wait until document is ready.

[This code](https://gist.github.com/tjbenton/4186f003329c623e53f5d4a31744b054) "monkey patched" a ready function onto `document`, I adopted it to not do the monkey patch.

### Usage

```js
import isReady from 'document-ready'

isReady().then(() => {
    // document ready, do stuff
})
```

or using async

```js
let do = async () => {
    await isReady()
    // do stuff
}
```

license: Unlicense

repository: wires/document-ready

repo_name: wires/document-ready


text:
# Hair Salon Management App

#### February 26th, 2016

#### By Chris Young

## Description

A hair salon app written in Java that assists owners in managing stylist/client relationships. Gives the user the ability to add a list of the stylists, and for each stylist, add clients who see that stylist. The stylists work independently, so each client only belongs to a single stylist. Utilizes a SQL database to store stylists and their clients.

## Setup

### In PSQL:
* CREATE DATABASE hair_salon;
* CREATE TABLE stylists (id serial PRIMARY KEY, stylist varchar);
* CREATE TABLE clients (id serial PRIMARY KEY, client varchar, stylist_id int);
* If you also want to run the tests I have written, run: CREATE DATABASE to_do_test WITH TEMPLATE to_do;