text:
# Load Testing Toolkit

> *“I have enough trouble with useful information, never mind being burdened with what is useless.”*\
> ― Erlend Loe, Naïve. Super

Collection of __open-source__ tools for debugging, benchmarking, load and stress testing your code or services.

__NOTE:__ Unfortunately I've found this original *awesome* collection too late: [__awesome-http-benchmark__](https://github.com/denji/awesome-http-benchmark).\
Feel free to follow and contribute to it instead of this collection, which remains my personal variation and working copy.

> In alphabetical order.

## Contents

* [Debugging & API testing](#debugging--api-testing)
* [Benchmarking & load testing](#benchmarking--load-testing)
* [DoS/DDoS penetration testing](#dosddos-penetration-testing)
* [Traffic replay](#traffic-replay)

## Debugging & API testing

* [__baloo__](https://github.com/h2non/baloo) - Expressive and versatile end-to-end HTTP API testing made easy in `Go`.
* [__bat__](https://github.com/astaxie/bat) - A [curl](https://github.com/curl/curl)-like tool for humans, inspired by [httpie](https://github.com/httpie/httpie), written in `Go`.
* [__curl__](https://github.com/curl/curl) - A command line tool and library for transferring data with URL syntax. `C`
* [__curlie__](https://github.com/rs/curlie) - The power of [curl](https://github.com/curl/curl), the ease of use of [httpie](https://github.com/httpie/httpie). `Go`
* [__curlx__](https://github.com/shivkanthb/curlx) - Supercharge [curl](https://github.com/curl/curl) with history, collections and more. `JavaScript`
* [__hopp-cli__](https://github.com/hoppscotch/hopp-cli) - An HTTP CLI client for [hoppscotch](https://hoppscotch.io/), an alternative to [curl](https://github.com/curl/curl), [httpie](https://github.com/httpie/httpie). `Go`
* [__httpcat__](https://github.com/httpie/httpcat) - A simple utility for constructing raw HTTP requests on the command line. `Python`
* [__httpie__](https://github.com/httpie/httpie) - Modern command line HTTP client, user-friendly [curl](https://github.com/curl/curl) alternative with intuitive UI, JSON support, syntax highlighting, wget-like downloads, extensions, etc. `Python`
* [__httpie-go__](https://github.com/nojima/httpie-go) - [httpie](https://github.com/httpie/httpie)-like HTTP client written in `Go`.
* [__httping__](https://github.com/BretFisher/httping-docker) - A ping-like utility for HTTP requests. `C`
* [__httpstat__](https://github.com/reorx/httpstat) - [curl](https://github.com/curl/curl) statistics visualization in a way of beauty and clarity. `Python`
* [__hurl__](https://github.com/Orange-OpenSource/hurl) - A command line tool to perform HTTP requests defined in a simple plain text format. `Rust`
* [__wuzz__](https://github.com/asciimoo/wuzz) - Interactive command line tool for HTTP inspection. `Go`
* [__xh__](https://github.com/ducaale/xh) – Yet another [httpie](https://github.com/httpie/httpie) clone in `Rust`.

## Benchmarking & load testing

### http/s

* [__ab__](https://httpd.apache.org/docs/current/programs/ab.html) - ApacheBench, single-threaded Apache HTTP server benchmarking tool. `C`
* [__ali__](https://github.com/nakabonne/ali) - A load testing tool capable of performing real-time analysis, inspired by [vegeta](https://github.com/tsenart/vegeta), written in `Go`.
* [__apachebench-ab__](https://github.com/CloudFundoo/ApacheBench-ab) - Standalone version of [ab](https://httpd.apache.org/docs/current/programs/ab.html), Apache HTTP server benchmarking tool. `C`
* [__apib__](https://github.com/apigee/apib) - A simple, fast HTTP and API benchmarking tool. `C++`
* [__autocannon__](https://github.com/mcollina/autocannon) - Fast HTTP/1.1 benchmarking tool written in `Node.js`, greatly inspired by [wrk](https://github.com/wg/wrk) and [wrk2](https://github.com/giltene/wrk2), with support for HTTP pipelining and HTTPS.
* [__baton__](https://github.com/americanexpress/baton) - HTTP load testing written in `Go`.
* [__beast__](https://github.com/jjmrocha/beast) - Stress testing for RESTful APIs. `Go`
* [__beeswithmachineguns__](https://github.com/newsapps/beeswithmachineguns) - An utility for arming (creating) many bees (micro EC2 instances) to attack (load test) targets (web applications). `Python`
* [__benchttp__](https://github.com/siadat/benchttp) - HTTP server benchmarking tool, implements the most commonly used features of [ab](https://httpd.apache.org/docs/current/programs/ab.html). `Go`
* [__bender__](https://github.com/pinterest/bender) - An easy-to-use library for creating load testing applications. `Go`
* [__bfg__](https://github.com/yandex-load/bfg) - A modular tool and framework for load generation with HTTP/2 support. `Python`
* [__blast__](https://github.com/dave/blast) - A simple, protocol agnostic tool for API load testing and batch jobs. `Go`
* [__bombardier__](https://github.com/codesenberg/bombardier) - Fast cross-platform HTTP benchmarking tool written in `Go`.
* [__boom__](https://github.com/tarekziade/boom) - A replacement for [ab](https://httpd.apache.org/docs/current/programs/ab.html), written in `Python`.
* [__carrot__](https://github.com/gophercarrot/carrot) - Distributed WebSocket and HTTP load testing framework in `Go`.
* [__cassowary__](https://github.com/rogerwelin/cassowary) - Modern cross-platform HTTP load testing tool written in `Go`.
* [__chaperon__](https://github.com/polleverywhere/chaperon) - HTTP service performance & load testing framework. `Elixir`
* [__clobbr__](https://github.com/parsecph/clobbr) - A tool to check the speed and resilience of API endpoints against multiple parallel or sequence requests. `JavaScript`
* [__curl-loader__](https://curl-loader.sourceforge.net/) - A load generating tool written in `C`, simulating HTTP/S, FTP/S and TLS/SSL clients each with own IP-address.
* [__drill__](https://github.com/fcsonline/drill) - A HTTP load testing application, written in `Rust`, inspired by Ansible syntax.
* [__encarno__](https://github.com/undera/encarno) - Load generator for HTTP with high throughput and high precision. `Go`
* [__f1__](https://github.com/form3tech-oss/f1) - A flexible load testing framework using `Go` for test scenarios.
* [__fasthttploader__](https://github.com/hagen1778/fasthttploader) - HTTP benchmark (kinda [ab](https://httpd.apache.org/docs/current/programs/ab.html)) with autoadjustment and charts based on fasthttp library. `Go`
* [__fbender__](https://github.com/facebookincubator/fbender) - A load testing command line tool for generic network protocols, originally based on [bender](https://github.com/pinterest/bender) library. `Go`
* [__fortio__](https://github.com/fortio/fortio) - Load testing library, command line tool, advanced echo server and web UI in `Go`.
* [__freeloader__](https://github.com/rprieto/freeloader) - Super easy load testing framework, with load scenarios in `JavaScript`.
* [__go-meter__](https://github.com/a696385/go-meter) - A HTTP benchmark tool written in `Go`.
* [__go-wrk__](https://github.com/adjust/go-wrk) - A small heavy duty HTTP/S benchmark tool, similar to [wrk](https://github.com/wg/wrk), but written in `Go`.
* [__goad__](https://github.com/goadapp/goad) - An AWS Lambda powered, highly distributed, load testing tool. `Go`
* [__gobench__](https://github.com/cmpxchg16/gobench) - HTTP/S load testing and benchmarking tool. `Go`
* [__gocannon__](https://github.com/kffl/gocannon) - A lightweight HTTP benchmarking tool, intended to measure changes in backend application performance over time. `Go`
* [__gohttpbench__](https://github.com/parkghost/gohttpbench) - An [ab](https://httpd.apache.org/docs/current/programs/ab.html)-like benchmark tool run on multi-core cpu. `Go`
* [__goku__](https://github.com/k-nasa/goku) - HTTP load testing application written in `Rust`.
* [__goku-bench__](https://github.com/jcaromiq/goku) - An HTTP load testing tool built out of a need to drill HTTP services inspired by [drill](https://github.com/fcsonline/drill) and [vegeta](https://github.com/tsenart/vegeta). `Rust`
* [__goose__](https://github.com/tag1consulting/goose) - A `Rust` load testing tool inspired by [locust](https://github.com/locustio/locust).
* [__goperf__](https://github.com/gnulnx/goperf) - `Go` based load tester with a simple intuitive command line syntax.
* [__hargo__](https://github.com/mrichman/hargo) - `Go` library and command line utility that parses HAR files, can convert to [curl](https://github.com/curl/curl) format, and serve as a load test driver.
* [__hey__](https://github.com/rakyll/hey) - HTTP load generator, [ab](https://httpd.apache.org/docs/current/programs/ab.html) replacement. `Go`
* [__htstress__](https://github.com/arut/htstress) - Fast HTTP benchmarking tool, similar to [ab](https://httpd.apache.org/docs/current/programs/ab.html) but provides multithreading support. `C`
* [__http_bench__](https://github.com/linkxzhou/http_bench) - An HTTP(/1/2/3) and WebSockets stress testing tool, with both single and distributed modes. `Go`
* [__httperf__](https://github.com/httperf/httperf) - A tool for measuring web server performance. `C`
* [__httpit__](https://github.com/gonetx/httpit) - A rapid HTTP/S benchmark tool, written in `Go`.
* [__httpress__](https://github.com/virtuozzo/httpress) - High performance HTTP server stress & benchmark utility, inspired by [weighttp](https://github.com/lighttpd/weighttp). `C`
* [__hulken__](https://github.com/hellgrenj/hulken) - Stress testing tool for everything speaking HTTP. `JavaScript`
* [__hurl__](https://github.com/edgio/hurl) - HTTP server load test and parallel [curl](https://github.com/curl/curl) utilities. `C++`
* [__iago2__](https://github.com/twitter/iago2) - A load generator, built for engineers. `Scala`
* [__jbender__](https://github.com/pinterest/jbender) - A port of [bender](https://github.com/pinterest/bender) to the JVM platform with Quasar lightweight threads (fibers) and channels. `Java`
* [__jetty-load-generator__](https://github.com/jetty-project/jetty-load-generator) - An API for load testing HTTP servers, based on Jetty's HttpClient and `Java` 11+.
* [__legion__](https://github.com/lane-webperformance/legion) - A `JavaScript`-based load testing tool for HTTP servers and other kinds of software.
* [__loadtest__](https://github.com/alexfernandez/loadtest) - A `JavaScript` package for load testing with HTTP/S and WebSockets support and API for easy integration.
* [__loadtesttoolbox__](https://github.com/ecoAPM/LoadTestToolbox) - Lightweight tools for load testing web applications, written in `C#`.
* [__mgun__](https://github.com/byorty/mgun) - A modern tool for load testing HTTP servers, written in `Go`.
* [__molotov__](https://github.com/tarekziade/molotov) - Simple `Python` 3.7+ tool to write load tests.
* [__nbomber__](https://github.com/PragmaticFlow/NBomber) - Very simple load testing framework for Pull and Push scenarios, written in `F#` and targeting .NET Core and full .NET Framework.
* [__netling__](https://github.com/hallatore/netling) - Load testing client for easy web testing. `C#`
* [__node-ab__](https://github.com/doubaokun/node-ab) - A command line tool to test the performance of HTTP services. `Node.js`
* [__node-vegeta__](https://github.com/jbarabander/node-vegeta) - `Node.js` bindings for the [vegeta](https://github.com/tsenart/vegeta) load testing library.
* [__oha__](https://github.com/hatoo/oha) - HTTP load generator, inspired by [hey](https://github.com/rakyll/hey) with tui animation. `Rust`
* [__pandora__](https://github.com/yandex/pandora) - A load generator in `Go`, with built-in HTTP/S and HTTP/2 support and load scenarios in `Go`.
* [__pewpew__](https://github.com/bengadbois/pewpew) - Flexible HTTP command line stress tester for websites and web services. `Go`
* [__plow__](https://github.com/six-ddc/plow) - A high-performance HTTP benchmarking tool with real-time web UI and terminal displaying. `Go`
* [__ponos__](https://github.com/klarna/ponos) - Simple yet powerful load generator written in `Erlang`.
* [__pounce__](https://github.com/fredrikwidlund/pounce) – HTTP benchmark utility, written in `C`.
* [__pronk__](https://github.com/bos/pronk) - A small command line application for load testing web servers. `Haskell`
* [__reqstress__](https://github.com/utkusen/reqstress) - A benchmarking & stressing tool that can send raw HTTP requests, written in `Go`.
* [__rewrk__](https://github.com/lnx-search/rewrk) - A modern HTTP framework benchmarking utility supporting HTTP/1 and HTTP/2 benchmarks. `Rust`
* [__salvo__](https://github.com/tarekziade/salvo) - Like [boom](https://github.com/tarekziade/boom), but based on [molotov](https://github.com/tarekziade/molotov). `Python`
* [__sb__](https://github.com/aliostad/SuperBenchmarker) - SuperBenchmarker, ApacheBench ([ab](https://httpd.apache.org/docs/current/programs/ab.html)) on steroids. `C#`
* [__siege__](https://github.com/JoeDog/siege) - A HTTP load tester and benchmarking utility. `C`
* [__slapper__](https://github.com/ikruglov/slapper) - Simple load testing tool with real-time updated histogram of request timings. `Go`
* [__slow_cooker__](https://github.com/BuoyantIO/slow_cooker) - A load tester focused on lifecycle issues and long-running tests. `Go`
* [__sniper__](https://github.com/btfak/sniper) - Powerful and high-performance HTTP load tester, written in `Go`.
* [__stress__](https://github.com/yarax/stress) - Simple `Node.js` tool for stress testing HTTP services.
* [__terjang__](https://github.com/andylibrian/terjang) - Scalable HTTP load testing tool built on [vegeta](https://github.com/tsenart/vegeta). `Go`
* [__thrash__](https://github.com/TylerBrock/thrash) - `Go` HTTP micro benchmarker.
* [__vegeta__](https://github.com/tsenart/vegeta) - HTTP load testing tool and library. `Go`
* [__vex__](https://github.com/vamsiikrishna/vex) - A small `PHP` app that sends some load to a web application.
* [__weighttp__](https://github.com/lighttpd/weighttp) - A lightweight and simple webserver benchmarking tool. `C`
* [__welle__](https://github.com/rylev/welle) - An [ab](https://httpd.apache.org/docs/current/programs/ab.html)-like benchmarking tool written in `Rust`.
* [__wrk__](https://github.com/wg/wrk) - Modern HTTP benchmarking tool. `C`
* [__wrk2__](https://github.com/giltene/wrk2) - A constant throughput, correct latency recording variant of [wrk](https://github.com/wg/wrk). `C`

### non-http/s

* [__amoc__](https://github.com/esl/amoc) - A simple framework for running massively parallel XMPP tests in a distributed environment. `Erlang`
* [__bench__](https://github.com/tylertreat/bench) - A generic latency benchmarking library. `Go`
* [__bomberman__](https://github.com/c1982/bomberman) - SMTP performance and load testing tool. `Go`
* [__dhammer__](https://github.com/ipchama/dhammer) - DHCP stress tester and benchmark tool. `Go`
* [__massive-attack__](https://github.com/delprks/massive-attack) - Load testing Thrift, made simple. `Scala`
* [__rpc-perf__](https://github.com/twitter/rpc-perf) - A tool for benchmarking RPC services. `Rust`
* [__rtmp_load__](https://github.com/fillest/rtmp_load) - A load testing tool for RTMP servers. `C`
* [__srs-bench__](https://github.com/ossrs/srs-bench) - A HTTP/RTMP/HLS load testing and benchmarking tool. `C++`
* [__ssh-hammer__](https://github.com/shazow/ssh-hammer) - A SSH load testing tool. `Go`
* [__tcpkali__](https://github.com/satori-com/tcpkali) - Fast multi-core TCP and WebSockets load generator. `C`

#### dns

* [__dnsblast__](https://github.com/sandeeprenjith/dnsblast) - A DNS performance testing utility. `Go`
* [__dnsblast__](https://github.com/jedisct1/dnsblast) - A simple and stupid load testing tool for DNS resolvers. `C`
* [__dnsmeter__](https://github.com/DNS-OARC/dnsmeter) - A tool for testing performance of nameservers and the infrastructure around it. `C++`
* [__dnsperf__](https://github.com/DNS-OARC/dnsperf) - DNS performance testing tools. `C`
* [__dnstress__](https://github.com/safedns/dnstress) - A DNS stress testing tool. `C`
* [__flamethrower__](https://github.com/DNS-OARC/flamethrower) - A DNS performance and functional testing utility, originally built as an alternative to [dnsperf](https://github.com/DNS-OARC/dnsperf). `C++`

#### grpc

* [__ghz__](https://github.com/bojand/ghz) - Simple gRPC benchmarking and load testing tool. `Go`
* [__strest-grpc__](https://github.com/BuoyantIO/strest-grpc) - A load tester for stress testing gRPC intermediaries. `Go`

#### kafka

* [__kafka-stress__](https://github.com/msfidelis/kafka-stress) - CLI tool to stress Apache Kafka clusters. `Go`
* [__sangrenel__](https://github.com/jamiealquiza/sangrenel) - Apache Kafka load testing. `Go`

#### mq

* [__emqtt-bench__](https://github.com/emqx/emqtt-bench) - A simple MQTT v5.0 benchmark tool written in `Erlang`.
* [__flotilla__](https://github.com/tylertreat/Flotilla) - Automated message queue orchestration for scaled-up benchmarking. `Go`
* [__mqperf__](https://github.com/softwaremill/mqperf) - A benchmark of message queues with data replication and at-least-once delivery guarantees. `Scala`
* [__mqtt-benchmark__](https://github.com/krylovsk/mqtt-benchmark) - A simple MQTT (broker) benchmarking tool. `Go`
* [__mqtt-stresser__](https://github.com/inovex/mqtt-stresser) - Load testing tool to stress MQTT message broker. `Go`
* [__mqttloader__](https://github.com/dist-sys/mqttloader) - Load testing tool for MQTT, capable of benchmark test for both MQTT v5.0 and v3.1.1 brokers. `Java`
* [__mqttwrk__](https://github.com/bytebeamio/mqttwrk) - A [wrk](https://github.com/wg/wrk)/[wrk2](https://github.com/giltene/wrk2)-inspired tool for scale and performance testing MQTT brokers. `Rust`
* [__rabbitmq-perf-test__](https://github.com/rabbitmq/rabbitmq-perf-test) - RabbitMQ performance testing tool. `Java`

### multi-protocol

* [__artillery__](https://github.com/artilleryio/artillery) - A modern load and functional testing toolkit written in `Node.js`, with test scenario scripting in `JavaScript`.
* [__ddosify__](https://github.com/ddosify/ddosify) - High-performance load testing and DDOS attack simulation tool, written in `Go`.
* [__gatling__](https://github.com/gatling/gatling) - A load and performance testing framework based on `Scala`, Akka and Netty.
* [__grinder__](https://github.com/cossme/grinder) - A distributed load testing framework written in `Java`, with test scenario scripting in `Jython` and `Clojure`.
* [__jagger__](https://github.com/griddynamics/jagger) - An open-source framework for Continuous Performance Testing written in `Java`.
* [__jmeter__](https://github.com/apache/jmeter) - A `Java` tool designed to load test functional behavior and measure performance of a variety of services, with a focus on web applications.
* [__k6__](https://github.com/grafana/k6) - A modern load testing tool, using `Go` and `JavaScript`.
* [__locust__](https://github.com/locustio/locust) - Scalable distributed load testing tool written in `Python`.
* [__multi-mechanize__](https://github.com/cgoldberg/multi-mechanize) - Performance and load testing framework written in `Python`.
* [__mzbench__](https://github.com/satori-com/mzbench) - Expressive, scalable load testing tool, with multiple protocols support. `Erlang`
* [__ngrinder__](https://github.com/naver/ngrinder) - Enterprise level performance testing solution based on [The Grinder](https://github.com/cossme/grinder). `Java`
* [__predator__](https://github.com/Zooz/predator) - A distributed open-source platform for load testing APIs using custom version of [artillery](https://github.com/artilleryio/artillery) as load testing engine. `Node.js`
* [__tank__](https://github.com/intuit/Tank) - A cloud native load testing platform. `Java`
* [__tsung__](https://github.com/processone/tsung) - A multi-protocol distributed load testing tool, developed in `Erlang`.
* [__yandex-tank__](https://github.com/yandex/yandex-tank) - An extendable load testing tool which is especially good as a part of an automated load testing suite. `Python`, `C`

### nosql

* [__memtier_benchmark__](https://github.com/RedisLabs/memtier_benchmark) - A high-throughput benchmarking tool for Redis & Memcached. `C++`
* [__redisbench__](https://github.com/panjiang/redisbench) - Redis & Redis cluster benchmarking tool. `Go`

### storage

#### data store

* [__go-ycsb__](https://github.com/pingcap/go-ycsb) - A Go port of Yahoo! Cloud Serving Benchmark ([YCSB](https://github.com/brianfrankcooper/YCSB)). `Go`
* [__ndbench__](https://github.com/Netflix/ndbench) - Netflix Data Store Benchmark, a pluggable cloud-enabled benchmarking tool that can be used across any data store system. `Java`
* [__ycsb__](https://github.com/brianfrankcooper/YCSB) - Yahoo! Cloud Serving Benchmark (YCSB), a framework and common set of workloads for evaluating the performance of different "key-value" and "cloud" serving stores. `Java`

#### io

* [__diskspd__](https://github.com/microsoft/diskspd) - A storage performance testing tool from the Windows, Windows Server and Cloud Server Infrastructure engineering teams at Microsoft. `C++`
* [__fio__](https://github.com/axboe/fio) - Flexible I/O tester. `C`
* [__ioarena__](https://github.com/pmwkaa/ioarena) - Embedded storage benchmarking tool. `C`

#### object storage

* [__cosbench__](https://github.com/intel-cloud/cosbench) - A benchmark tool for cloud object storage service. `Java`
* [__mongoose__](https://github.com/emc-mongoose/mongoose) - Distributed storage performance testing tool. `Java`
* [__ostorebench__](https://github.com/EVERYGO111/OStoreBench) - A benchmark tool for distributed object storage systems. `Go`

#### time-series

* [__prometheus-benchmark__](https://github.com/VictoriaMetrics/prometheus-benchmark) - Benchmark for Prometheus-compatible systems on production-like workload. `Go`
* [__tsbs__](https://github.com/timescale/tsbs) - Time Series Benchmark Suite, a tool for comparing and evaluating databases for time series data. `Go`

### k8s

* [__k8s-bench-suite__](https://github.com/InfraBuilder/k8s-bench-suite) - Simple scripts to benchmark Kubernetes cluster features. `Shell`
* [__k8s-netperf__](https://github.com/jtaleric/k8s-netperf) - Running networking performance tests against Kubernetes. `Go`
* [__k-bench__](https://github.com/vmware-tanzu/k-bench) - Workload benchmark for Kubernetes. `Go`
* [__kboom__](https://github.com/mhausenblas/kboom) - The Kubernetes scale & soak load tester, equivalent of [boom](https://github.com/tarekziade/boom), written in `Go`.
* [__kube-burner__](https://github.com/cloud-bulldozer/kube-burner) - A tool aimed at stressing Kubernetes clusters by creating or deleting a high quantity of objects. `Go`

### graphql

* [__easygraphql-load-tester__](https://github.com/EasyGraphQL/easygraphql-load-tester) - A `Node.js` library created to make load testing on GraphQL based on the schema.
* [__graphql-bench__](https://github.com/hasura/graphql-bench) - A versatile tool for benchmarking and load testing GraphQL services, as a CLI application or via programmatic API. `TSQL`

### blockchain

* [__caliper__](https://github.com/hyperledger/caliper) - A blockchain benchmark framework to measure performance of multiple blockchain solutions. `JavaScript`
* [__gohammer__](https://github.com/tubuarge/gohammer) - A blockchain test tool designed to get performance metrics of the nodes and operation system by deploying a smart contract and calling smart contract's methods. `Go`

## DoS/DDoS penetration testing

> For educational and security/stress testing (as part of development) purposes only.

* [__finshir__](https://github.com/isgasho/finshir) - A coroutines-driven Low & Slow traffic sender, written in `Rust`.
* [__golden-eye__](https://github.com/jseidl/GoldenEye) - HTTP DoS test tool using HTTP Keep Alive + NoCache as attack vector. `Python`
* [__goloris__](https://github.com/valyala/goloris) - [Slowloris](https://github.com/gkbrk/slowloris) implementation for nginx DoS written in `Go`.
* [__hulk__](https://github.com/grafov/hulk) - Original HULK web server DoS attack tool ported to `Go` with some additional features.
* [__hulk-v3__](https://github.com/Hyperclaw79/HULK-v3) - `Python` 3 compatible async HULK script for DDoS attacks.
* [__lor-axe__](https://github.com/ajmwagar/lor-axe) - A multi-threaded, low-bandwidth HTTP DoS tool, written in `Rust`.
* [__slowhttptest__](https://github.com/shekyan/slowhttptest) - A highly configurable application layer DoS attack simulator. `C++`
* [__slowloris__](https://github.com/gkbrk/slowloris) - Low bandwidth DoS tool, rewrite in `Python`.
* [__wreckuests__](https://github.com/abriginets/wreckuests) - Yet another one hard-hitting tool to run DDoS attacks with HTTP-flood. `Python`

## Traffic replay

* [__goreplay__](https://github.com/buger/goreplay) - A network monitoring tool which can record live traffic, and use it for shadowing, load testing, monitoring and detailed analysis. `Go`
* [__ripley__](https://github.com/loveholidays/ripley) - HTTP traffic replay tool at multiples of the original rate. `Go`
* [__tcpcopy__](https://github.com/session-replay-tools/tcpcopy) - A TCP stream replay tool to support real testing of server applications. `C`

## Contribute

Contributions are welcome!\
Read the [CONTRIBUTING](CONTRIBUTING.md) guidelines first.

repository: aliesbelik/load-testing-toolkit

repo_name: aliesbelik/load-testing-toolkit


text:
# Rust CHIP-8 Interpreter

Hello!, my name is Alex Crossley. This is my personal take on a Rust ported CHIP-8 Interpreter (will refer to as just interpreter).

All of the resources and documents used to create my version of the interpreter are listed in the [wiki](https://github.com/AlbeyAl/Rust-Chip-8/wiki) of this repository.

There is also a [Discord server](https://discord.gg/s5hmv8s) setup to allow a community discussion about CHIP-8.

license: MIT

branch_name: refs/heads/master

extension: md

gha_license_id: MIT

license_type: permissive


text:
[![Build Status](https://semaphoreci.com/api/v1/projects/6449b778-9dd2-49c8-a12a-18e14b3d91a1/1094949/shields_badge.svg)](https://semaphoreci.com/consultaremedios/kinesis-rb)
[![Code Climate](https://codeclimate.com/repos/584ff2ceb0a5853f8a004266/badges/c1b9c8f8ea3358daebf0/gpa.svg)](https://codeclimate.com/repos/584ff2ceb0a5853f8a004266/feed)
[![Test Coverage](https://codeclimate.com/repos/584ff2ceb0a5853f8a004266/badges/c1b9c8f8ea3358daebf0/coverage.svg)](https://codeclimate.com/repos/584ff2ceb0a5853f8a004266/coverage)
[![Issue Count](https://codeclimate.com/repos/584ff2ceb0a5853f8a004266/badges/c1b9c8f8ea3358daebf0/issue_count.svg)](https://codeclimate.com/repos/584ff2ceb0a5853f8a004266/feed)

# Kinesis

Kinesis is a wrapper for [the official AWS SDK client](https://github.com/aws/aws-sdk-ruby).

## Installation

Add this line to your application's Gemfile:

```ruby
gem 'kinesis'
```

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install kinesis

## Usage

### Producer

The producer streaming a single event by api call.

```ruby
producer = Kinesis.build_producer('my_stream')

event = 'event to be streamed'

producer.produce(event)
```

It's possible to send a collection of events using a single api call, using the `multi_produce`.

```ruby
producer = Kinesis.build_producer('my_stream')

events = [
  'some event',
  'another event'
]

producer.multi_produce(events)
```

### Consumer

The consumer fetches all shards from the stream and loops over each shard fetching events
calling the block for every iteration.

After each shard loop a checkpoint is saved using the last sequence number read from Kinesis record.
The checkpoint storage by default is in memory, using the `Kinesis::Storage::Memory` instance, but
it can be stored on Redis, using the `Kinesis::Storage::Redis` instance, for a persistent checkpoint when the process is restarted.

```ruby
consumer = Kinesis.build_consumer('my_stream')

while true do
  consumer.consume do |shard, events|
    do_something(events)
  end
end
```

By default the consumer fetches `1000` events each time, but you can set a different limit size.

```ruby
redis = Redis.new
storage = Kinesis::Storage::Redis.new(redis)
consumer = Kinesis.build_consumer('my_stream', storage: storage)

while true do
  consumer.consume(100) do |shard, records|
    do_something(records)
  end
end

```

## Development

After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).

## Contributing

Bug reports and pull requests are welcome on GitHub at https://github.com/ConsultaRemedios/kinesis.

## License

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

repository: ConsultaRemedios/kinesis-rb

gha_language: Ruby

repo_name: ConsultaRemedios/kinesis-rb


text:
# Behavioral Cloning

## _A project of Self-Driving Car Engineer Nanodegree_

[![Udacity - Self-Driving Car Engineer Nanodegree](https://s3.amazonaws.com/udacity-sdc/github/shield-carnd.svg)](http://www.udacity.com/drive)

### The goals / steps of this project are the following:
* Use the simulator to collect data of good driving behavior
* Build, a convolution neural network in Keras that predicts steering angles from images
* Train and validate the model with a training and validation set
* Test that the model successfully drives around track one without leaving the road

---

In this project, you, as a driver, need to train a neural network to keep a car driving in the center of the lane line. Udacity car simulator ([Windows](https://s3-us-west-1.amazonaws.com/udacity-selfdrivingcar/Term1-Sim/term1-simulator-windows.zip) [Mac](https://s3-us-west-1.amazonaws.com/udacity-selfdrivingcar/Term1-Sim/term1-simulator-mac.zip) [Linux](https://s3-us-west-1.amazonaws.com/udacity-selfdrivingcar/Term1-Sim/term1-simulator-linux.zip)) is used to train the network and test how good the model behave on the road, well of course, in the simulator.

## The model architecture

The model used in this project contains 9 layers, including a normalization layer, 5 convolutional layers, and 3 fully connected layers. It is inspired by PilotNet mentioned in a research [paper](http://images.nvidia.com/content/tegra/automotive/images/2016/solutions/pdf/end-to-end-dl-using-px.pdf) published by Nvidia Self-driving Team.

- the normalization layer
  - used to cut off unrelated information from the camera image, such as sky, trees, and car botnet, which will make the model more generalized
  - the reset of the image data is then normalized with zero mean
  - all these helps reduce the size of the model and speed up the training
- the convolutional layers
  - the first 3 layers are processed with 3x3 stride with kernel size 5x5
  - the last 2 layers are processed by a 3x3 kernel with no stride
  - these layers are used to extract features of from the camera image
- the fully connected layers
  - designed to act as control layers to provide steering angle decision according to the features detected from previous convolutional layers
- activation layer
  - ReLu activation is used through out the network to provide non-linearity of the model
  - since this is a regression network, the final output is the steering angle, thus no activation layer is attached
- dropout layer
  - to prevent overfitting, a dropout rate of 0.5 is applied to the output of the first 2 fully connected layers

Here is the Keras network summary:

```
_________________________________________________________________
Layer (type)                 Output Shape              Param #
=================================================================
cropping2d_1 (Cropping2D)    (None, 65, 320, 3)        0
_________________________________________________________________
lambda_1 (Lambda)            (None, 65, 320, 3)        0
_________________________________________________________________
conv2d_1 (Conv2D)            (None, 31, 158, 24)       1824
_________________________________________________________________
conv2d_2 (Conv2D)            (None, 14, 77, 36)        21636
_________________________________________________________________
conv2d_3 (Conv2D)            (None, 5, 37, 48)         43248
_________________________________________________________________
conv2d_4 (Conv2D)            (None, 3, 35, 64)         27712
_________________________________________________________________
conv2d_5 (Conv2D)            (None, 1, 33, 64)         36928
_________________________________________________________________
flatten_1 (Flatten)          (None, 2112)              0
_________________________________________________________________
dense_1 (Dense)              (None, 100)               211300
_________________________________________________________________
dropout_1 (Dropout)          (None, 100)               0
_________________________________________________________________
dense_2 (Dense)              (None, 50)                5050
_________________________________________________________________
dropout_2 (Dropout)          (None, 50)                0
_________________________________________________________________
dense_3 (Dense)              (None, 10)                510
_________________________________________________________________
dense_4 (Dense)              (None, 1)                 11
=================================================================
Total params: 348,219
Trainable params: 348,219
Non-trainable params: 0
_________________________________________________________________
```

As shown above, there are a total of 348,219 parameters to train in the network.

## Model training

The model get trained by observing how you drive. The simulator has two modes: training and autonomous driving. You first drive on the track and capture driving data used for training. Then, the data, the captured images, will be used to train your network.

- collect driving data
  - a total of 51,390 images are collected, and 20% of it are reserved for validation
  - one lap of driving in the center of the lane

  - one lap of driving in the center of lane, but revers direction
  - recovery driving to drive the car from side of the road back onto lane center

  - data collected from 3 cameras, e.g. left, center, right, are used

- data preprocessing
  - all the collect images are left-right flipped to expend the training dataset for more generalized network
  - the camera collected RBG images are converted to YUV color space before sent to the model
  - the sequence of the images can affect the trained model, so, for each epoch of training, the dataset are shuffled randomly to eliminate the affect
- training
  - as the model is trained on my laptop, which only has 4GB GPU memory to use, Python generator is used to keep the memory usage manageable, a batch size of 32 is used here
  - an Adam optimizer is used so that manually training the learning rate wasn't necessary
  - since we are predicting the steering angle, Mean Square Error (MSE) loss is used to determine the model quality

The model converges quite quickly. The validation dataset start to reach <0.015 after 3 epochs.

## Running the project

1. Start the simulator in training mode, and collect driving examples.

   Alternertively, you can get a copy of the driving data from this [link](https://d17h27t6h515a5.cloudfront.net/topher/2016/December/584f6edd_data/data.zip). Extract the data in to folder, so that you have the following folder structure:
   ```txt
   data
     |
     |-- IMG
     |    |
     |    |-- *.jpg
     |
     |-- driving_log.csv
   ```
2. Train model
   ```sh
   python model.py
   ```
3. Test model in simulator
   ```sh
   python drive.py model.h5 video
   ```
   Start simulator in autonomous driving mode. The car should start driving by itself. All copy of the driveing footage will be saved in the `video` folder.
4. Generate testing footage
   ```sh
   python video.py video
   ```
   `video.mp4` will be generated.

Here is a sample output from my trained model.

[![Watch the video](https://img.youtube.com/vi/jrNxl5diAsM/mqdefault.jpg)](https://youtu.be/jrNxl5diAsM)

Note:
- The first 2 minutes of the video is to test how the car can recovery from the side of the road. You may find the footage is a bit stucky, which is due to I constantly pull the car towards the curbs manually. As shown in the video, when I pull the car to the side of the road in both straight lane and curves, the car can always recovery itself back onto the middle of the lane.
- The rest of the video demonstrated the car can self-drive for the whole lap. It navigate through the curves smoothly and keeps itself in the center of the lane all the time.

gha_language: Python


text:
---
layout: post
title: "Scapes News"
date: 2016-12-5 12:00:00
image: '/assets/img/project_screenshots/scapes_news1.png'
description:
tags:
- XML
- Ruby
- Ruby on Rails
- HTML5
- Nokogiri
categories:
- Web Applications
twitter_text:
---

> The code for the front-end can be found on GitHub here

One day I decided that I didn't want my news by category, geo, or typical aggregations. I simply wanted to choose the sources I trusted and aggregate the results into news that I found interesting. That's why I created this news application, Scapes News.

![UML](../assets/img/project_screenshots/scapes_news2.png)

It is a simple application that allows the user to provide the link to an xml feed they find interesting through a basic dashboard, then it parses out the information into an easy-to read format.

![UML](../assets/img/project_screenshots/scapes_news3.png)

Is this going to change the world? No. But it is useful if you want to take directly control of your news sources to cut out the noise.


text:
## Remove `typename ::type` from type\_traits

### Before

```cpp
#include <type_traits>
using namespace std;

template <
            class... Args,
            class ElemType =
                typename decay<
                    typename common_type<Args...>::type
                >::type
            >
inline constexpr
typename enable_if<
    (sizeof...(Args) > 0),
    array<ElemType, sizeof...(Args)>
>::type
make_array(Args &&... args)
{
    return {{ forward<ElemType>(args)... }};
}
```

###After

```cpp
#include <aliases/iterator_traits.hpp>
using namespace aliases;

template <
            class... Args,
            class ElemType =
                decay< common_type<Args...> >
            >
inline constexpr
enable_if<
    (sizeof...(Args) > 0),
    array<ElemType, sizeof...(Args)>
>
make_array(Args &&... args)
{
    return {{ forward<ElemType>(args)... }};
}
```

### Requirements

A compiler must implements Template Aliases, a C++11 feature.

- clang 3.0 or later
- gcc 4.7 or later
- VC++ not implemented yet

### License

Distributed under MIT license.

  Copyright (c) 2013 rhysd

  Permission is hereby granted, free of charge, to any person obtaining
  a copy of this software and associated documentation files (the
  "Software"), to deal in the Software without restriction, including
  without limitation the rights to use, copy, modify, merge, publish,
  distribute, sublicense, and/or sell copies of the Software, and to
  permit persons to whom the Software is furnished to do so, subject to
  the following conditions:
  The above copyright notice and this permission notice shall be
  included in all copies or substantial portions of the Software.

  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


text:
# Concept
Econ Source is a project that combines the free spirit of Open Source Software, the rigurosity of Economics and the practicality of Data Science.
We believe that many interesting real-life challenges can be solved through the methods of Economics but many obstacles still remain for it to become mainstream.
This project is about working together for removing those obstacles, and to expand the boundaries of Economics beyond academia and into the real world for the benefit of everyone.
It is based on four principles:

### Share
We share our code for everyone to use it freely under the Apache 2.0 license.
We welcome contributions, and we are open to bug reports, feature requests, and look forward to hearing about your use cases.
Feel free to use the libraries here for your personal research, study or work.

### Build
Done is better than perfect, and what you'll find here is just done.
We hope for active participation from researchers, data scientists, students, people in the academia, the industry, and specially anyone who shares this vision.
We aim for high-quality software that is at the same time easy to understand and to contribute to.
We encourage test-oriented development, and the usage of best practices in software development.

### Discuss
We appreciate and encourage polite and constructive discussion.

### Learn
One of the best things about Open Source is that everyone makes each other better.
We aim to maintain easy-to-read code from which anyone willing to learn can find a hint.
Papers in Empirical Economics can sometimes be very shallow regarding the implementation details of algorithms.
Did you ever want to see a code implementation of an algorithm, but the paper is not very detailed about it? Check the unit tests or the source code here, maybe you'll find a clue.
Have you thought of contributing to an open source project but don't know where to start? Well, what about here?

# Working together

In DSOC we see great value in each encounter.
We hope that *Econ Source* can become the starting point for collaboration, be it software development, empirical research or business.
There are many opportunities to collaborate with us:

### Through Code
If you have a bug report or feature request, fill an Issue stating the name of the library. We appreciate your code contributions as well.
See the README file on each library for details about details on developing, testing, code conventions, etc.

### Collaborative Research
*Sansan Data Discovery* is our collaborative research platform. Learn more about it [here](https://en.sansan-dsoc.com/research/datadiscovery/).

To know more about the kind of research we perform at DSOC, check our [Data Science Reports](https://sansan-dsoc.com/research/report/) (only in Japanese).

repository: sansan-inc/econ-source

repo_name: sansan-inc/econ-source


text:
## GOKU

[![Go Report Card](https://goreportcard.com/badge/github.com/eolinker/goku)](https://goreportcard.com/report/github.com/eolinker/goku) [![Releases](https://img.shields.io/github/release/eolinker/goku/all.svg?style=flat-square)](https://github.com/eolinker/goku/releases) [![LICENSE](https://img.shields.io/github/license/eolinker/goku.svg?style=flat-square)](https://github.com/eolinker/goku/blob/main/LICENSE)
![](https://shields.io/github/downloads/eolinker/goku/total)
![](http://data.eolinker.com/course/ZjVKwg65f0af2f992b0ce0fcfd64d04da1696dcab3853ee.png)

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

Goku API gateway is a api gateway developed based on golang. It can achieve the purposes of high-performance HTTP API forwarding, multi tenant management, API access control, etc. it has a powerful custom plug-in system, which can be expanded by itself, and can quickly help enterprises manage API services and improve the stability and security of API services.

**Note**：The **main** branch is the main development branch. Frequent updates may lead to unstable use. If you need to use a stable version, please look [release](https://github.com/eolinker/goku/releases)

### Summary / [中文介绍](https://github.com/eolinker/goku/blob/main/README_CN.md)

- [WhyGoku](#WhyGoku "Why Goku")
- [Feature](#Feature)
- [Benchmark](#Benchmark)
- [Deployment](#Deployment)
- [GetStart](#GetStart "Get Start")
- [Contact](#Contact)
- [About](#About)

### Why Goku

Goku API gateway is a microservice gateway running on the service boundary of enterprise system. When you build websites, apps, iots and even open API transactions, Goku API gateway can help you extract duplicate components from your internal system and run them on Goku gateway, such as user authorization, access control, firewall, data conversion, etc; Moreover, Goku provides the function of service arrangement, so that enterprises can quickly obtain the required data from various services and realize rapid response to business.

Goku API gateway has the following advantages:

- Completely open source: the Goku project is initiated and maintained by eolinker for a long time. We hope to work with global developers to build the infrastructure of micro service ecology.
- Excellent performance: under the same environment, Goku is about 50% faster than nginx, Kong and other products, and its stability is also optimized.
- Rich functions: Goku provides all the functions of a standard gateway, and you can quickly connect your micro services and manage network traffic.
- Extremely low use and maintenance cost: Goku is an open source gateway developed in pure go language. It has no cumbersome deployment and no external product dependence. It only needs to download and run, which is extremely simple.
- Good scalability: most of Goku's functions are modular, so you can easily expand its capabilities.

In a word, Goku API gateway enables the business development team to focus more on business implementation.

[![Stargazers over time](https://starchart.cc/eolinker/goku.svg)](#)

### Feture

| Feture            | Description                                                  |
| ----------------- | ------------------------------------------------------------ |
| Dynamic router    | Match the corresponding service by setting parameters such as location, query, header, host and method |
| Service discovery | Support such as Eureka, Nacos and Consul                     |
| Load Balance      | Support polling weight algorithm                             |
| Authentication    | Anonymous, basic, apikey, JWT, AK / SK authentication        |
| SSL certificate   | Manage multiple certificates                                 |
| Access Domain     | The access domain can be set for the gateway                 |
| Health check      | Support health check of load nodes to ensure service robustness |
| Protocol          | HTTP/HTTPS、Webservice                                       |
| Plugin            | The process is plug-in, and the required modules are loaded on demand |
| OPEN API          | Gateway configuration using open API is supported            |
| Log               | Provide the operation log of the node, and set the level output of the log |

#### RoadMap

- **Cluster**：Use **raft ** algorithm to build clusters to ensure high program availability
- **Cli**：Support cli command control gateway program
- **UI**： The gateway configuration can be operated through the UI interface, and different UI interfaces (Themes) can be customized by loading as required
- **Multi protocol**：Support a variety of protocols, including but not limited to grpc, websocket, TCP / UDP and Dubbo
- **Traffic control**：Intercept abnormal traffic
- **Black and white list**：Set the static IP black-and-white list to intercept illegal IP
- **Plugin Market**：Because Goku mainly loads the required modules through plug-in loading, users can compile the required functions into plug-ins, or download and update the plug-ins developed by contributors from the plug-in market for one click installation
- **Service Orchestration**：An orchestration API corresponds to multiple backends. The input parameters of backends support client input and parameter transfer between backends; The returned data of backend supports filtering, deleting, moving, renaming, unpacking and packaging of fields; The orchestration API can set the exception return when the orchestration call fails
- **Monitor**：Capture the gateway request data and export it to Promethus and graphite for analysis
- .....

#### RoadMap  for 2021

![image](https://user-images.githubusercontent.com/25589530/131605703-698222c6-42fb-4242-b47d-d962d949cdcf.png)

### Benchmark

![](http://data.eolinker.com/course/6Md3iDR8e64ebc99af18b628851c0b75a8a2061b4b26ff1.png)

### Deployment

* Direct Deployment：[Deployment Tutorial](https://help.gokuapi.com/?path=/quick/arrange)
* [Quick Start Tutorial](https://help.gokuapi.com/?path=/quick/quick_course)
* [Source Code Compilation Tutorial](https://help.gokuapi.com/?path=/quick/arrange)
* Docker：Follow up support
* Kubernetes：Follow up support

### Get start

1. Download and unzip the installation package (here is an example of the installation package of version v0.1.0)

```
wget https://github.com/eolinker/goku/releases/download/v0.1.0/goku-v0.1.0.linux.x64.tar.gz && tar -zxvf goku-v0.1.0.linux.x64.tar.gz && cd goku
```

2. Start gateway：

```
./goku -data_path {data_path}
```

### Contact

- **Help documentation**：[https://help.gokuapi.com](https://help.gokuapi.com)
- **QQ group**: 725853895
- **Slack**：[加入我们](https://join.slack.com/t/slack-zer6755/shared_invite/zt-u7wzqp1u-aNA0XK9Bdb3kOpN03jRmYQ)
- **Official website**：[https://www.gokuapi.com](https://www.gokuapi.com)

### About

Eolinker is a leading API management service provider, providing professional API R & D management, API automation testing, API monitoring, API gateway and other services to more than 3000 enterprises around the world. It is the first enterprise to formulate API R & D management industry specifications for ITSS (China Electronics Industry Standardization Technology Association).

Official website：[https://www.eolinker.com](https://www.eolinker.com "EOLINKER官方网站")
Download PC desktop for free：[https://www.eolinker.com/pc/](https://www.eolinker.com/pc/ "免费下载PC客户端")

repository: mfzzz/goku

branch_name: refs/heads/main

repo_name: mfzzz/goku


text:
# dto-types

![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)[![npm](https://img.shields.io/npm/v/dto-types.svg)](https://www.npmjs.com/package/dto-types)

DtoTypes is middleware for express based on [PropTypes](https://github.com/facebook/prop-types).
PropTypes are an effective mechanism for keeping track of what a component should be receiving,
so why not extend the idea to a DTOs (data transfer objects). I've found myself, instead writing custom validation
for every api route I write. Hopefully this alleviates that by specifying the dto shapes only one time.

[NPM](https://www.npmjs.com/package/dto-types)

## Installation

```shell
npm install --save dto-types
```

## Use

```js
import { DtoTypes, DtoValidator } from 'dto-types'; // ES6

const orderDtoType = {
  total: DtoTypes.number.isRequired,
  items: DtoTypes.arrayOf(DtoTypes.shape({
    name: DtoTypes.string.isRequired,
    price: DtoTypes.number.isRequired,
  }).isRequired,
}

app.post('/orders', DtoValidator(orderDtoType), (req, res) => { // do stuff })
```

repository: Imundy/dto-types

repo_name: Imundy/dto-types


text:
On Apple platforms, a networking security feature called App Transport
Security (ATS) is available to apps and app extensions, and is enabled
by default. It improves privacy and data integrity by ensuring your
app's network connections employ only industry-standard protocols and
ciphers without known weaknesses. This helps instill user trust that
your app does not accidentally leak transmitted data to malicious
parties.

By configuring this key's value in your app's `Info.plist` file, you can
customize the security of your network connections in a variety of ways.
You can:

- Allow insecure communication with particular servers
- Allow insecure loads for web views or for media, while maintaining ATS protections elsewhere in your app
- Enable new security features such as Certificate Transparency

repository: appknox/vulnerabilities

repo_name: appknox/vulnerabilities


text:
# Discord CAS

Tool for user verification via CAS on Discord server. If your organization uses
CAS for authentication, and if you also run a Discord server whose private
contents should only be accessible to CAS authenticated users, then this is the
right tool for you.

Once a user are authenticated on any one server, they will not need to repeat
the whole signup process on another server.

## Wiki

Head over to the [wiki](https://github.com/Groverkss/Discord-CAS/wiki) to
learn how to add the bot to your server / host it for your own organization.

## Contributions

Feel free to make a PR/issue for feature implementation/request.

Formating for python is done with Black with a 80 character limit.
Formating for javascript isnt strict as long as 80 character limit is followed.

## Privacy policy

When a user authenticates with our web portal, we store their following
information: 1. Full Name 2. Email 3. Roll number 4. DiscordID. 1,2,3 are
obtained from CAS, and 4 is obtained from Discord. All these are obtained after
user gives consent through authentication.

This data is used strictly for authentication only, and not visible publicly.
It is only visible to the server host.

The bot does not track any interactions. If a user does not authenticate with
our portal, we store no data.

## License

MIT

repository: deutranium/Discord-CAS

repo_name: deutranium/Discord-CAS


text:
# Evaluation of packer detection tool for FFRI Dataset scripts

## About this repository

In order to resolve [the issue of FFRI Dataset scripts](https://github.com/FFRI/ffridataset-scripts/issues/1), we evaluated some existing OSS packer detection tools.

In this repository, we compare the performance of tools that provide heuristic packer detections (e.g., few import APIs, existence of sections with high entropy, broken rich header, ...).

Note that we previously published similar repository [PackerDetectionToolEvaluation](https://github.com/FFRI/PackerDetectionToolEvaluation), but it focused on the evaluation of signature-based packer detection tools.

## Targets

- [PyPackerDetect](https://github.com/cylance/PyPackerDetect)
- [Manalyze](https://github.com/JusticeRage/Manalyze)
- [pypeid](https://github.com/FFRI/pypeid)

## Dataset

We use [PackingData](https://github.com/chesvectain/PackingData) dataset for this evaluation.

Note that we fixed [the issue of PackingData](https://github.com/FFRI/PackerDetectionToolEvaluation#packingdata) for this evaluation.

## Result

TPR is almost the same between PyPacker and Manalyze; its value is about 94%.
The performance of pypeid is slightly lower than these two tools.

On the other hand, FPR was much lower when using PyPacker or pypeid compared with Manalyze.

|   | TPR  | FPR  |
|:-:|:-:|:-:|
| PyPackerDetect | 94.6% | 2.2% |
| Manalyze | 95.0% | 41.0% |
| pypeid | 84.9% | 5.6%|

See [Jupyter Notebook](./analyze_packing_data.ipynb) for more details.

## Author

Koh M. Nakagawa. © FFRI Security, Inc. 2020

## License

[Apache version 2.0](./LICENSE)

repository: FFRI/PackerDetectorConsideration

repo_name: FFRI/PackerDetectorConsideration


text:
# CyLang
A language for json parse which contains params or expression

# Introduce
###### Now when we start develop a RESTful api or JsonRpc,we often use json as a data type,because it's easy to unstand and simple to right!
###### When we post or get from a url,we also use json to package params!So I think we need a language to parse params or express in json param.
###### If that ,we can use params to get value from system or databases,or others.

# 1、Main idea
#### This frame contains flows:
##### core: This is the frame core code ,it's main function is to design the langage
##### utils:This is the util that often use ,such get system time,user profile,etc.
##### parse: This is the internal language parser,also provide interface to implement by user.
##### grammar: This is the internal grammer in this frame,also provide interface to implement new grammer by user.

## language rules flows:
### ${name}:like jsp's el expression,name is the param's name
###\##1+1##:it's a expression,we will evaluate it as js expression.for example,##1+1##的值为2
### {if ${name}}aaaaaa{/if}:this is if expression,name is the param key,${name} will be evalute boolean value through javascript programm

### Release Note
#### 2018-02-01
* **增加parser.properties**:
    * 通过配置grammar可以动态设置grammar启用的列表
    * 增加sortType:可以通过排序方式，如果为true则启用配置文件grammar中的配置顺序，否则启用每个grammar注解文件下的seq从小到大的排序方式启动
* **增加parser.properties**:增加包扫描方法ClassScanUtils.getAllClass(扫描classpath下的文件)和ClassScanUtils.getAllClassIncludeJar(扫描jar中的class文件和classpath下的文件)

```Java
    String content = "${a}${b}##${cd}+${dd}##{if ${cd}}${ed}{/if}";
    Map<String,String> map = new HashMap<String,String>();
    map.put("a","a");
    map.put("b","b");
    map.put("cd","1");
    map.put("dd","2");
    map.put("ed","3");
    String result = new Handler().execute(content,map);
    System.out.println(result);

    >> ab33
```

## To be continued!!!!!!

repository: cyssxt/cy-lang

repo_name: cyssxt/cy-lang


text:
Clockwise
=========

[![Build Status](https://ci.appveyor.com/api/projects/status/github/jonsequitur/Clockwise?svg=true&branch=master)](https://ci.appveyor.com/project/jonsequitur/Clockwise)

| Package    | Version  |
|:-----------|:--------|
| Clockwise                 |  [![NuGet Status](http://img.shields.io/nuget/v/Clockwise.svg?style=flat)](https://www.nuget.org/packages/Clockwise/)
| Clockwise.AzureServiceBus | [![NuGet Status](http://img.shields.io/nuget/v/Clockwise.AzureServiceBus.svg?style=flat)](https://www.nuget.org/packages/Clockwise.AzureServiceBus/)

Clockwise is a lightweight command dispatcher, scheduler, and handler library. It has a particular focus on testability. Clockwise approaches the pain of testing message-based systems by providing in-memory scheduling and clock-jumping features, as well as support for retries and idempotency. These in-memory implementations can be used as functionally equivalent substitutes to the storage-backed implementations.

repository: jonsequitur/Clockwise

gha_language: C#

repo_name: jonsequitur/Clockwise


text:
# Monster Rolodex (React)

## Description
This is a simple page with React.It was built as a project to show people who might not be familiar with the syntax in React,concepts including elements, components, props, and state.

You can see the demo version here:
### [Demo](https://alinutzab.github.io/monsters-rolodex/)

## Instalation
- Clone the repo in your terminal by clicking the _green_ clone or download button at the top right and copying the url
- In your terminal, type ```git clone URL```
  - replace URL with the url you copied
  - hit enter
- This will copy all the files from this repo down to your computer
- In your terminal,  cd react-app (the directory you just created)
- Type ```npm install``` to install all dependencies
- Last, but not least, type ```npm start``` to run the app locally.

## License
This project is open source and available under the MIT License.

repository: alinutzaB/monsters-rolodex

repo_name: alinutzaB/monsters-rolodex


text:
[//]: <> (Copyright 2015, Jesper Derehag<EMAIL_ADDRESS>for Ericsson AB)
[//]: <> (All rights reserved.)

[//]: <> (Redistribution and use in source and binary forms, with or without modification,)
[//]: <> (are permitted provided that the following conditions are met:)

[//]: <> (1. Redistributions of source code must retain the above copyright notice, this list of conditions)
[//]: <> (and the following disclaimer.)

[//]: <> (2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the)
[//]: <> (following disclaimer in the documentation and/or other materials provided with the distribution.)

[//]: <> (THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED)
[//]: <> (WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A)
[//]: <> (PARTICULAR PURPOSE ARE DISCLAIMED.
This is calculated as the number of new-line characters per file (and function).

### Diff counts
All diff counts are calculated using python difflib.unified_diff which is based on an algorithm published by
Ratcliff and Obershelp under the hyperbolic name [gestalt pattern matching][unified_diff]

* added
  database: **change\_metrics.added**
  metric_name: **added**
  The number of lines (nloc) that have been added since previous version.

* changed
  database: **change\_metrics.changed**
  metric_name: **changed**
  The number of lines (nloc) that have been changed (not added or deleted) since previous version.

* deleted
  database: **change\_metrics.deleted**
  metric_name: **deleted**
  The number of lines (nloc) that have been deleted from the previous version.

* changerate
  database: **N/A**
  metric_name: **changerate**
  The sum of added, changed, deleted since previous version.

##Number of tokens
database: **change_metrics.token\_count**
metric_name: **token\_count**

The number of whitespace delimited words in each file-function

##Number of parameters
database: **change_metrics.paramater\_count**
metric_name: **parameter\_count**

The number of parameters a function takes. If viewed on a subsystem or file level it indicates the sum of all functions
 up to the parent level.

##McCabes cyclomatic complexity.
database: **change_metrics.cyclomatic\_complexity**
metric name: **cyclomatic\_complexity**

###Theory
Measures the number of linearly independent paths through a program's source code.
It typically does this by building a graph where nodes are "commands" (i.e control statements in the language).

Furthermore, a number of studies have investigated cyclomatic complexity's correlation to the number of defects
contained in a function or method. Some studies find a positive correlation between cyclomatic complexity and defects:
functions and methods that have the highest complexity tend to also contain the most defects, however the correlation
between cyclomatic complexity and program size has been demonstrated many times and since program size is not a
controllable feature of commercial software the usefulness of McCabes's number has been called to question.
The essence of this observation is that larger programs (more complex programs as defined by McCabe's metric)
tend to have more defects.
The above text is in parts taken from [Wikipedia/Cyclomatic_Complexity][wikipedia complexity]
The article is really a recommended read for an overiew of Cyclomatic Complexity.

[McCabe original paper][mccabe original]

###Implementation
Calculated using [lizard][lizard]
Lizard uses "fuzzy parsing" and is therefore rather poor at identifying method scopes.
"fuzzy parsing" is fancy-speak for "finding control statements using regular expressions".
So some methods (also macro/template functions) gets reported on the previous method (usually global scope).

##Effective cyclomatic complexity
database: **N/A**
metric name: **effective\_complexity**

###Theory
The effective cyclomatic complexity of a file.
Calculated by the sum of all the functions with cyclomatic complexity >15 divided by the number of functions.
Effective complexity as defined by [Vard Antinyan][Risky files]

###Implementation
FYI. since it's calculated on file level it doesn't exist on function level.

##Defect modifications
database: **defect\_modifications**
metric_name: **defect\_modifications**

The number of identified modifications for each defect per function. In other words, we save a row
(with locality file/function) in the database for each identified commit that is marked as a defect-modification.

###Implementation
To classify a modification as a defect modification we parse the VCS for metadata matching a specific pattern.

1. ClearCase
   Search through any branch name matching regex, and report it as defect-modification branch if it has been
   delivered (anywhere)

2. git
   Search through each commit message looking for regex.

##Revisions
database column name: **change\_metrics**
metric_name: **revisions**

1. ClearCase
   Each new checkin on any of the LSV branches is counted as a revision.
   LSV branches have either of the following branch names: *main, mpg\_lsv\_int, ggsn\_lsv\_int*

2. git
   Each new commit is counted as a new revision.
   In git we are only counting master branch.

##Defect density
database column name: **N/A**
metric_name: **defect\_density**

Defect density is a metric that somewhat tries to indicate the average number of defects per lines of code.
It is however highly controversial in that it makes a size estimation based on LOC, which poorly translates across
languages (and even inside languages but different coding paradigms). It is therefore a dangerous to use it as a
comparison between subsystems since without detailed knowledge about both systems one can't really know what programming
paradigms are used and if they are comparable. But that beeing said, it is still atleast an attempt at removing size
as a confounding factor in estimating "quality". Variations on defect density definitions exist and you can read more
about defect_density [here][defect density].
In general, industry and academia prefers function points \(FP\) for size estimation. However calculating FP is so far
a manual process and are thus for practical reasons not implemented here. Instead we use:

defect_density = defect\_modifications/nloc

But once again, keep in mind that nloc is perceived as a poor size estimation metric, and results will be highly
contextual.

[unified_diff]:http://www.drdobbs.com/database/pattern-matching-the-gestalt-approach/184407970
[wikipedia complexity]:http://en.wikipedia.org/wiki/Cyclomatic_complexity
[lizard]:http://www.lizard.ws/
[mccabe original]:http://www.google.se/books?id=vtNWAAAAMAAJ&hl=sv&pg=PR1#v=onepage&q&f=false
[Risky files]:http://web.student.chalmers.se/~vard/files/Identifying%20Risky%20Areas%20of%20Software%20Code.pdf
[defect density]:http://softwaretestingfundamentals.com/defect-density/

repository: jderehag/swat

gha_language: JavaScript

repo_name: jderehag/swat


text:
# Aiven Terraform Provider
The Terraform provider for [Aiven.io](https://aiven.io/), an open source data platform as a service.

**See the [official documentation](https://registry.terraform.io/providers/aiven/aiven/latest/docs) to learn about all the possible services and resources.**

## 🚨 A word of caution 🚨
Recreating stateful services with Terraform will possibly **delete** the service and all its data before creating it again. Whenever the Terraform plan indicates that a service will be **deleted** or **replaced**, a catastrophic action is possibly about to happen.

Some properties, like **project** and the **resource name**, cannot be changed and it will trigger a resource replacement.

To avoid any issues, **please set the `termination_protection` property to `true` on all production services**, it will prevent Terraform to remove the service until the flag is set back to `false` again. While it prevents a service to be deleted, any logical databases, topics or other configurations may be removed **even when this section is enabled**. Be very careful!

## Quick Start
- [Signup for Aiven](https://console.aiven.io/signup?utm_source=github&utm_medium=organic&utm_campaign=terraform&utm_content=signup)
- [Get your authentication token and project name](https://help.aiven.io/en/articles/2059201-authentication-tokens)
- Create a file named `main.tf` with the content below:
```hcl
terraform {
  required_providers {
    aiven = {
      source  = "aiven/aiven"
      version = "x.y.z" # check out the latest version in the release section
    }
  }
}

provider "aiven" {
  api_token = "your-api-token"
}

resource "aiven_pg" "postgresql" {
  project                = "your-project-name"
  service_name           = "postgresql"
  cloud_name             = "google-europe-west3"
  plan                   = "startup-4"

  termination_protection = true
}

output "postgresql_service_uri" {
  value     = aiven_pg.postgresql.service_uri
  sensitive = true
}
```

- Run in your terminal:
```bash
$ terraform init
$ terraform plan
$ terraform apply
$ psql "$(terraform output -raw postgresql_service_uri)"
```

Voilà, a PostgreSQL database.

## Developing
### Requirements
- [Terraform](https://www.terraform.io/downloads.html) v0.12.X or greater
- [Go](https://golang.org/doc/install) 1.16.X or greater
### Cloning
```bash
$ git clone https://github.com/aiven/terraform-provider-aiven.git
```
### Building
Run the command below. It will generate the binaries under the `plugins/$OS_$ARCH` folder.
```bash
$ make bins
```

### Testing
Run the tests with the command below:
```bash
$ make test
```

Run the acceptance tests with the commands below:
```bash
$ export AIVEN_TOKEN="your-token"
$ export AIVEN_PROJECT_NAME="your-project-name"

$ make testacc

# or run a specific acceptance test
$ make testacc TESTARGS='-run=TestAccAiven_kafka'
```

> Acceptance tests create real resources, and often cost money to run.

For information about writing acceptance tests, see the main [Terraform contributing guide](https://www.terraform.io/docs/extend/testing/acceptance-tests/index.html).

## Debugging
### Requirements
- [Terraform](https://www.terraform.io/downloads.html) v0.12.26 or greater
- [Delve](https://github.com/go-delve/delve/tree/master/Documentation/installation) 1.7.X or greater

### Starting the Provider Plugin with `dlv`

To start debugging the provider we use the `dlv debug` command and pass the `-debug` flag to the compiled binary:

```bash
$ dlv debug -- -debug
Type 'help' for list of commands.
(dlv)
```

Next, we set a breakpoint at a function that we want to look into and continue to start the plugin:

```bash
(dlv) break resourceServiceCreate
Breakpoint 1 set at 0x129667b for github.com/aiven/terraform-provider-aiven/aiven.resourceServiceCreate() ./aiven/resource_service.go:806
(dlv) c
{"@level":"debug","@message":"plugin address","@timestamp":"2021-10-12T16:36:45.528158+02:00","address":"/tmp/plugin252726151","network":"unix"}
Provider started, to attach Terraform set the TF_REATTACH_PROVIDERS env var:
    TF_REATTACH_PROVIDERS='{"registry.terraform.io/aiven/aiven":{"Protocol":"grpc","ProtocolVersion":5,"Pid":3153652,"Test":true,"Addr":{"Network":"unix","String":"/tmp/plugin252726151"}}}'
```

Next, in a different terminal session we start terraform using the `TF_REATTACH_PROVIDERS` environment variable:

```bash
$ export TF_REATTACH_PROVIDERS='{"registry.terraform.io/aiven/aiven":{"Protocol":"grpc","ProtocolVersion":5,"Pid":3153652,"Test":true,"Addr":{"Network":"unix","String":"/tmp/plugin252726151"}}}'

$ terraform init -upgrade
<...>
$ terraform plan
<...>
$ terraform apply -parallelism=1
<...>
aiven_pg.testing: Creating...
```

Now we can see that the debugged process did hit the breakpoint we specified earlier:

```bash
> github.com/aiven/terraform-provider-aiven/aiven.resourceServiceCreate() ./aiven/resource_service.go:806 (hits goroutine(326):1 total:1) (PC: 0x129667b)
   801:			return resourceServiceCreate(ctx, d, m)
   802:		}
   803:
   804:	}
   805:
=> 806:	func resourceServiceCreate(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
   807:		client := m.(*aiven.Client)
   808:		serviceType := d.Get("service_type").(string)
   809:		userConfig := ConvertTerraformUserConfigToAPICompatibleFormat("service", serviceType, true, d)
   810:		vpcID := d.Get("project_vpc_id").(string)
   811:		var apiServiceIntegrations []aiven.NewServiceIntegration
```

### Adding Dependencies
This provider uses [Go modules](https://blog.golang.org/using-go-modules).

To add a new dependency to your Terraform provider:

```bash
go get github.com/author/dependency
go mod tidy
```

Then commit the changes to `go.mod` and `go.sum`.

## License
[MIT License](LICENSE).

## Credits

The original version of the Aiven Terraform provider was written and maintained by [Jelmer Snoeck](https://github.com/jelmersnoeck).

repository: antomatic/terraform-provider-aiven

repo_name: antomatic/terraform-provider-aiven


text:
# Home-assistant Addons

[![License][license-shield]](LICENSE.md)

## About

addons that i use personally

## Installation

Follow [the official instructions](https://home-assistant.io/hassio/installing_third_party_addons/) on the Home Assistant website and use the following URL:

```txt
https://github.com/bmanojlovic/home-assistant-addons
```

## Addons provided by this repository

### [borg-backup][homeassistant-borg-backup]

repository: bmanojlovic/home-assistant-addons

repo_name: bmanojlovic/home-assistant-addons


text:
# React Multiplayer AI Game
This is a dynamic game that allows users to choose whether they want to play a game with either a 3x3 or 4x4 board.

If the user choses a 3x3 board, they have the option to play against a human or an AI player.

The AI player uses the MiniMax algorithm, a backtracking algorithm that will always find the optimal move.

## :video_game: Play the Game! :video_game:
[Click here to view the application](https://strangeforloop.github.io/react-mulitplayer-ai/)

## :black_small_square:	What I Learned
### Testing via React Testing Library
(Coming soon . . .)

### Project Limitations
(Coming soon . . .)

## License

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

## Links
* [Minimax Algorithm](https://en.wikipedia.org/wiki/Minimax)

repository: strangeforloop/react-mulitplayer-ai

repo_name: strangeforloop/react-mulitplayer-ai


text:
# juniper_subscriptions

This repository contains [SubscriptionCoordinator][SubscriptionCoordinator] and
[SubscriptionConnection][SubscriptionConnection] implementations for
[Juniper][Juniper], a [GraphQL][GraphQL] library for Rust.

## Documentation

For this crate's documentation, check out [API documentation][documentation].

For `SubscriptionCoordinator` and `SubscriptionConnection` documentation, check
out [Juniper][Juniper].

## Examples

Check [examples/warp_subscriptions][example] for example code of a working
[warp][warp] server with GraphQL subscription handlers.

## Links

* [Juniper][Juniper]
* [API Reference][documentation]
* [warp][warp]

## License

This project is under the BSD-2 license.

Check the LICENSE file for details.

[warp]: https://github.com/seanmonstar/warp
[Juniper]: https://github.com/graphql-rust/juniper
[SubscriptionCoordinator]: https://docs.rs/juniper/latest/juniper/trait.SubscriptionCoordinator.html
[SubscriptionConnection]: https://docs.rs/juniper/latest/juniper/trait.SubscriptionConnection.html
[GraphQL]: http://graphql.org
[documentation]: https://docs.rs/juniper_subscriptions
[example]: https://github.com/graphql-rust/juniper/blob/master/examples/warp_subscriptions/src/main.rs

repository: LegNeato/juniper

gha_language: Rust

repo_name: LegNeato/juniper


text:
---
templateKey: blog-post
title: Outlook Performance Tips
path: blog-post
date: 2008-03-31T12:03:45.429Z
description: "I’ve been living with Outlook 2007 since it shipped, and it’s been
  pretty painful, but my life is in it so I’m stuck with it. "
featuredpost: false
featuredimage: /img/default-post-image.jpg
tags:
  - Microsoft Office
  - Outlook
category:
  - Uncategorized
comments: true
share: true
---
<!--StartFragment-->

I’ve been living with Outlook 2007 since it shipped, and it’s been pretty painful, but my life is in it so I’m stuck with it. I’ve posted some [Outlook tips](http://aspadvice.com/blogs/ssmith/archive/2007/05/14/Outlook-Data-File-PST-Not-Closed-Properly.aspx) in the past about how to deal with it not shutting down properly, and that has grown into a fairly sizable post with dozens of comments (and #1 for the search term [outlook did not shut down properly](https://www.google.com/search?q=outlook+did+not+shut+down+properly&rls=com.microsoft:*:IE-SearchBox&ie=UTF-8&oe=UTF-8&sourceid=ie7&rlz=1I7ADBF). Nice.). Anyway, I have some additional tips that I thought would be worth sharing.

**Use Exchange If You Can**

In general, most of the people I’ve talked to say that Outlook 2007 doesn’t have any huge performance problems when it is working with Exchange. This makes perfect sense to me since I’m sure Microsoft uses Exchange extensively and they probably would have noticed if its performance were complete poo in this scenario. If you can, use Outlook with Exchange to get the best experience.

**Avoid Touching Multiple PSTs At Once**

The biggest issue with performance that I notice with Outlook 2007 is disk access. The program goes nuts with disk access any time it’s doing anything (and sometimes when it doesn’t appear to be doing anything). What makes this worse is if you have several PST files (because of course you want them to be small – see below) and you’ve set up rules to move things automatically between your main PST and one or more others. This takes the disk access problem from bad to horrendous, and will really slow things down. Ideally, you should have everything dump into one PST file. If you need to keep it from getting too big, you should periodically archive it to one or more others (and don’t plan on Outlook being responsive while you do so – do it before heading to lunch or something).

**Keep Your PSTs Small and Defragged**

Outlook is heavily disk IO bound with its data store. Watch your hard drive light while it’s checking email to see this in action. The larger your PST files get, the longer they take to read and write and the more likely they are to be fragmented all over your physical disk. Since [your disk is most likely the biggest bottleneck in your whole computer](http://www.codinghorror.com/blog/archives/000800.html), you want to avoid this as much as possible. You can also go buy a faster drive, but barring that, you should keep your PST files under 1GB if possible and keep individual folders under 5,000 or so items in it ([YMMV](http://en.wikipedia.org/wiki/Your_mileage_may_vary) – it depends on what they are). Your ideal setup should be 2 PST files, one that is small that all new mail arrives in (and is filed into) and another that is largely static but is periodically filled via archiving (and frequently backed up).

I still find that POP3 access via Outlook is abysmal. I haven’t found any fix for this yet, but the above tips should help improve your Outlook performance.

<!--EndFragment-->

repository: ShadyNagy/ardalis-com-gatsby

repo_name: ShadyNagy/ardalis-com-gatsby


text:
---
slug: create-a-namespace
id: 73t0tporqu4q
type: challenge
title: Create a namespace
teaser: Let's start easy
notes:
- type: text
  contents: |-
    Google Kubernetes Engine is a **fully managed and enterprise grade** Kubernetes platform.

    With Kubernetes Engine you can focus on deploying and managing **containerized microservices** while leaving the **node, network, and other low level maintenance** to Google.
- type: text
  contents: |-
    Kubernetes Engine is a **Certified Kubernetes** platform with many additional features designed to give you the power and flexibility you need.

    From **built in autoscaling, VPC native networking, global load balancing, and addons like Knative and Istio**, Kubernetes Engine gives you the tools you need to build **cloud native applications**.
- type: text
  contents: One of the most important concepts in Kubernetes is that of a **Namespace**.
    Namespaces are used to organize resources in your cluster.
tabs:
- title: Shell
  type: terminal
  hostname: shell
difficulty: basic
timelimit: 300
---
Use `help` and `hint`

repository: GoogleCloudPlatform/instruqt-content

gha_language: Shell

repo_name: GoogleCloudPlatform/instruqt-content


text:
# Scala PDF module

This module helps in generating PDF documents dynamically from your Scala application.
It simply renders your HTML- and CSS-based templates to PDF.

It is based on the Flying Saucer library, which in turn uses iText for PDF generation.

## Installation
```
libraryDependencies += "com.viajobien" %% "scala-pdf" % "0.1.0"
```

## Usage

```
val body = /* some xhtml string */
val renderer = new PdfRenderer(classLoader)
val bytes = renderer.toBytes(body)
```

Please see the `PdfRendererSpec.scala` file for an example of loading.

repository: shannonbarnes/scala-pdf

repo_name: shannonbarnes/scala-pdf


text:
| Supported Targets | ESP32-S2 | ESP32-S3 |
| ----------------- | -------- | -------- |

# USB Mass Storage Class example

## Overview

This example demonstrates usage of Mass Storage Class to get access to storage on USB memory stick.
Upon connection of USB stick, storage is mounted to Virtual filesystem. Example then creates `ESP` subdirectory(if not present already), as well as `text.txt` file. Its content is then repetitively printed to monitor until USB stick is manually ejected. User can decide whether or not to deinitialize the whole
USB stack or not by shorting GPIO10 to ground. When GPIO10 is left unconnected USB stack is not deinitialized, USB stick can be plugged-in again.

### Hardware Required

* Development board with USB capable ESP SoC (ESP32-S2/ESP32-S3)
* A USB cable for Power supply and programming
* A USB memory stick

### Common Pin Assignments

If your board doesn't have a USB A connector connected to the dedicated GPIOs,
you may have to DIY a cable and connect **D+** and **D-** to the pins listed below.

```
ESP BOARD    USB CONNECTOR (type A)
                   --
                  | || VCC
[GPIO19]  ------> | || D-
[GPIO20]  ------> | || D+
                  | || GND
                   --
```

Additionally, GPIO10 can be shorted to ground in order to deinitialize USB stack after ejecting USB stick.

### Build and Flash

Build the project and flash it to the board, then run monitor tool to view serial output:

```
idf.py -p PORT flash monitor
```

(To exit the serial monitor, type ``Ctrl-]``.)

See the Getting Started Guide for full steps to configure and use ESP-IDF to build projects.

## Example Output

```
...
I (274) cpu_start: Starting scheduler on PRO CPU.
I (339) APP: Waiting for USB stick to be connected
Device info:
         PID: 0x5678
         VID: 0xFFFF
         iProduct: Disk 2.0
         iManufacturer: USB
         iSerialNumber: 92072836B2589224378
I (719) APP: Writing file
I (749) APP: Reading file
I (749) APP: Read from file: 'Hello World!'
I (759) APP: Done
```

repository: igrr/esp-idf

gha_language: C

repo_name: igrr/esp-idf


text:
## AdminClient Example

The standard admin API provided by Kafka clients prioritizes flexibility, which is great if you need that, but awkward if you don't (and much of the time you won't).

This example demonstrates a simplified Admin API for working with Kafka topics. Available methods:

- `CreateTopicAsync` - Create a single topic.
- `CreateTopicMaybeAsync` - Create a topic if it doesn't exist.
- `DeleteTopicAsync` - Delete a topic (throws if topic doesn't exist)
- `DeleteTopicMaybeAsync` - Delete a topic, if it exists.
- `DescribeTopicAsync` - Get configs for a single topic.

repository: MCKanpolat/howlett-kafka-extensions

repo_name: MCKanpolat/howlett-kafka-extensions


text:
[This document is automatically generated. All changed made to it WILL be lost]: <>

# SQL Server Rule: SRP0005

|    |    |
|----|----|
| Assembly | SqlServer.Rules.dll   |
| Namespace | SqlServer.Rules.Performance |
| Class | ConsiderAddingSetNoCountOnRule |

## Rule Information

|    |    |
|----|----|
| Id | SRP0005 |
| Friendly Name | Noisy trigger |
| Category | Performance |
| Ignorable | true |
| Applicable Types | Dml Trigger  |
|   | Procedure |

## Description

SET NOCOUNT ON is recommended to be enabled in stored procedures and triggers.

## Summary

SET NOCOUNT ON is recommended to be enabled in stored procedures and triggers


text:
## Demo
Open `build/index/html` in the browser

## Requirements
Node >= v4.0.0

## Development mode
`npm install && npm start`

license: ISC

repository: terryx/task-management

repo_name: terryx/task-management


text:
# Date: 26 November 2020

## Question:
Suppose you are given two matrices, $A$ with dimension $m \times n$ and $B$ with dimension $n \times l$. What would be the dimension of matrice resulting from the multiplication $A$ and $B$ i.e $A \times B$?

## Topic:
1. Data Science
2. Linear Algebra

## Options:
1. $m \times n$
2. $n \times l$
3. $m \times l$
4. $n \times n$

## Correct Option:
3. $m \times l$

## Explanation:
For general matrices, the product $C = AB$ is defined as

$$
C_{ij} = \sum_i^k A_{ik}B_{kj}
$$

$A$ and $B$ must have same inner dimensions, implying that if $A$ has dimension $m \times n$ and $B$ has dimesnion $n \times l$, then the resultant matrix $C$ would have the dimension $m \times l$.

## Scripts:
1. Question Script: NULL
2. Answer Script: NULL

## Link:
1. Question Link: NULL
2. Answer Link:
   1. "Data science design manual by Steven Skiena"

## Images:
1. Question Images: NULL
2. Answer Images: NULL

gha_language: HTML


text:
[![](https://img.shields.io/badge/license-MIT-green)](https://https://github.com/Apoorva99/GSOC-Equivariant-Network/blob/main/LICENSE.md)

# Equivariant Neural Networks for Dark Matter Morphology with Strong Gravitational Lensing

* Current convolutional neural networks are only capable of translational equivariance. However, in a number of application (including ours), a larger groups of symmetries, including rotations and reflections are present in the data as well that needs to be exploited. This gives rise to the notion of Equivariant Convolutional Networks.
* E2-CNNs (proposed by Weiler et. al) propose a solution to this by guaranteeing a specified transformation behavior of their feature spaces under transformations of their input.
* E2-CNNs are equivariant under all isometries E(2) of the image plane i.e. under translations, rotations and reflections.
* We design a network that uses equivariant convolutional layers instead of a vanilla convolutional layer to capture the symmetries present in the data.

# Datasets

* We use two different datasets to train and test our network:
  * **Model F** (corresponding to model A in the paper)
  * **Model J** (corresponding to model B in the paper)
* The paper mentioned above refers to Alexander, Stephon, et al. "[Deep Learning the Morphology of Dark Matter Substructure](https://arxiv.org/abs/1909.07346)." The Astrophysical Journal 893.1 (2020): 15.
* Both model F and J contain 75000 images for training and 7500 images for testing. The images are evenly divided with each of the three class having 25000 training images and 2500 testing images.

# File Description

* **create_env.sh:** Bash file to create a conda environment and install all the dependencies needed.
* **Example.ipynb:** A sample notebook for the code of equivariant network.
* **dataset.py:** Dataloader to load the data for model_f and model_j.
* **main.py:** Script for loading the data, initialising the model and training the network.
* **model.py:** Contains the models to be used (Equivariant Network).
* **trainer.py:** Script for training the model and saving the results in the generated directory.
* **resnet_model.py:** Script containing the code for ResNet-18 model.

# Training the Network

```
$ python main.py [ARGS]
```
You can set the parameters of the model using the command line parameters. Description of the parameters used is shown in the table below:

| Argument | Description | Options | Default |
| --- | --- | --- | --- |
| `--data_dir` | Path of the dataset folder to be used. | string | images_f |
| `--sym_group` | Specify the group symmetry to be used if equivariant network is to be used | string

Circular

Dihyderal
 | Circular |
| `--N` | Order of the symmetry group | int | 4 |
| `--use_CNN` | True, if use simple convolution (ResNet18) | Bool:- True/False | False |
| `--epochs` | Number of epochs to train the network | int | 30 |
|`--batch_size` | Batch size to be used while training the network | int | 64 |
| `--lr` | Learning rate for training | Float | 5e - 5 |
| `--mode` | Specify training or testing mode | string

Train

Test
 | Train |
| `--test_time` | Name of the folder containing the model with timestamp (if testing with pretrained weights)| string |  |
| `--use_cuda` | True, if use GPU | Bool:- True/False | True |
|`--cuda_idx` | Which cuda device index to use | int | 0 |

Sample of a command to run Dihyderal symmetry group of 8 order on model J dataset:

```
$ python main.py --data_dir images_j --sym_group Dihyderal --N 8
```

**NOTE:** You can download the pre-trained models from [here](https://drive.google.com/drive/folders/1HTz0fO2Vtlsq1QZesGUOi84QQzy5KhDM?usp=sharing)

# Results
A folder name [dataset name]_[First letter of symmtry group]_[order of symmetry group] will be created. It will contain a folder having the name as the timestamp at which the code was run. The results will be located inside this folder as:

| Folder/File | Description |
| --- | ---|
| `log_[timstamp at which code was run]` | Contains loss and accuracy at each epoch |
| `code.py` | Copy of the python script executed |
| `best-model-parameters.pt` | Saved model with best performance on testing data |
| `train_loss.npy` | Numpy file containing the training losses |
| `test_loss.npy` | Numpy file containing the testing losses |
| `train_accuracy.npy` | Numpy file containing the training accuracies |
| `test_accuracy.npy` | Numpy file containing the testing accuracies |
| `accuracy.png` | Image showing the training and testing accuracies at different epochs |
| `loss.png` | Image showing the training and testing losses at different epochs |
| `ROC.png` | Image of the ROC curve |
| `CM.png` | Image of the confusion matrix |

## Cite

This project implements the ideas from the work [General E(2)-Equivariant Steerable CNNs](https://arxiv.org/abs/1911.08251).

```
@inproceedings{e2cnn,
    title={{General E(2)-Equivariant Steerable CNNs}},
    author={Weiler, Maurice and Cesa, Gabriele},
    booktitle={Conference on Neural Information Processing Systems (NeurIPS)},
    year={2019},
}
```
This project is the follow up work of the previous attempts to study and determine the morphology of dark matter substructure using deep learning based approaches. It is recommended to go through the following works for a clearer understanding of the problem formulation and the attempts made for substructure studies in the past.

```
@article{alexander2020deep,
  title={Deep Learning the Morphology of Dark Matter Substructure},
  author={Alexander, Stephon and Gleyzer, Sergei and McDonough, Evan and Toomey, Michael W and Usai, Emanuele},
  journal={The Astrophysical Journal},
  volume={893},
  number={1},
  pages={15},
  year={2020},
  publisher={IOP Publishing}
}
```
```
@article{alexander2020decoding,
  title={Decoding Dark Matter Substructure without Supervision},
  author={Alexander, Stephon and Gleyzer, Sergei and Parul, Hanna and Reddy, Pranath and Toomey, Michael W and Usai, Emanuele and Von Klar, Ryker},
  journal={arXiv preprint arXiv:2008.12731},
  year={2020}
}
```


text:
![GitHub release (latest by date)](https://img.shields.io/github/v/release/navigateconsulting/virtual-assistant)
[![GitHub license](https://img.shields.io/github/license/navigateconsulting/virtual-assistant)](https://github.com/navigateconsulting/virtual-assistant/blob/master/LICENSE)
![GitHub Workflow Status](https://img.shields.io/github/workflow/status/navigateconsulting/virtual-assistant/Docker)
![Docker](https://github.com/navigateconsulting/virtual-assistant/workflows/Docker/badge.svg?branch=master)

Virtual Assistant

## Table of Contents

* [About the Project](#about-the-project)
  * [Built With](#built-with)
* [Getting Started](#getting-started)
  * [Prerequisites](#prerequisites)
  * [Installation](#installation)
* [Usage](#usage)

## About The Project

### Built With

We used below projects to build the application stack.

rasa

angular

python flask

mongodb

redis

## Getting Stated

We use [Docker hub](https://hub.docker.com/u/navigateconsulting) to publish docker container images.

### Prerequisites

   - Docker version 18.09 onwards. (not tested on previous versions)
   - Docker Compose version 1.24 onwards (not tested on previous versions)
   - Linux Distributions (Windows not supported as of now, tested on ubuntu)

### Installation

If the project is to be deployed for production, please follow instructions for production deployment in below section

#### Quick Installation

Download the docker-compose.yml file with below command

    wget https://raw.githubusercontent.com/navigateconsulting/virtual-assistant/master/docker-compose.yml

And start the application with a simple docker compose up command.

    docker-compose up -d

This will start the application user interface on port 8080.

#### Production Mode

For production deployment, all the user interface containers are recommended to be on TLS. Refer docker-compose.tls_example.yml file
for how to configure and secure the deployment. Example contains a Letscert container which handles certificates and reissue on expiry.

Ensure below environment variables are set for containers which are to be secured.

      - VIRTUAL_HOST=subdomain.domain.com
      - VIRTUAL_PORT=port_no
      - LETSENCRYPT_HOST=subdomain.domain.com
      -<EMAIL_ADDRESS>
For example , to secure the Ui-Trainer application , modify the docker compose file and add above mentioned environment
variables as shown below

      va_api_gateway:
        init: true
        build: './va_api_gateway'
        environment:
          - PORT_APP=3000
          - WORKERS=1
          - THREADS=50
          - REDIS_URL=redis
          - REDIS_PORT=6379
          - MONGODB_HOST=mongodb
          - MONGODB_PORT=27017
          - RASA_SERVER=http://rasa:5005/model
          - VIRTUAL_HOST=subdomain.domain.com
          - VIRTUAL_PORT=port_no
          - LETSENCRYPT_HOST=subdomain.domain.com
          -<EMAIL_ADDRESS>        ports:
          - "3000:3000"
        volumes:
          - rasa_projects:/rasa_projects
        depends_on:
          - redis

After modifying the docker compose file. First start the tls containers by running below command

    docker-compose -f docker-compose.tls_example.yml up -d

and once the containers are up, start the application stack.

    docker-compose up -d

#### For Development

If you intent to extend the stack and make changes to the code base , follow below instructions to clone the repo and build containers from source

    git clone https://github.com/navigateconsulting/virtual-assistant
    cd virtual-assistant
    docker-compose -f docker-compose.build_from_source.yml build
    docker-compose -f docker-compose.build_from_source.yml up

**Note:  docker-compose.yml file uses docker hub to pull docker containers and does not build from source.

### Documentation

You can find detailed documentation [here](https://navigateconsulting.github.io/virtual-assistant/)

## Usage
   Usage instructions : [click here](docs/usage/Readme.md)

## License

[Apache 2.0](LICENSE)

repository: trinh-hoang-hiep/virtual-assistant

repo_name: trinh-hoang-hiep/virtual-assistant